             return
         }
         
-        if let finalURL = finalURLs[identifier], let duration = durations[identifier], let samples = samples[identifier]?[numberOfSamples] {
-            let result = VoiceMessageAttachmentCacheManagerLoadResult(eventIdentifier: identifier, url: finalURL, duration: duration, samples: samples)
-            completion(Result.success(result))
-            return
-        }
-        
-        self.enqueueLoadAttachment(attachment, identifier: identifier, numberOfSamples: numberOfSamples, completion: completion)
+        workQueue.async {
+            // Run this in the work queue to preserve order
+            if let finalURL = self.finalURLs[identifier], let duration = self.durations[identifier], let samples = self.samples[identifier]?[numberOfSamples] {
+                let result = VoiceMessageAttachmentCacheManagerLoadResult(eventIdentifier: identifier, url: finalURL, duration: duration, samples: samples)
+                DispatchQueue.main.async {
+                    completion(Result.success(result))
+                }
+                return
+            }
+            
+            self.enqueueLoadAttachment(attachment, identifier: identifier, numberOfSamples: numberOfSamples, completion: completion)
+        }
     }
     
     private func enqueueLoadAttachment(_ attachment: MXKAttachment, identifier: String, numberOfSamples: Int, completion: @escaping (Result<VoiceMessageAttachmentCacheManagerLoadResult, Error>) -> Void) {
-
-        if var callbacks = completionCallbacks[identifier] {
+        let callbackKey = CompletionCallbackKey(eventIdentifier: identifier, requiredNumberOfSamples: numberOfSamples)
+        
+        if var callbacks = completionCallbacks[callbackKey] {
             callbacks.append(CompletionWrapper(completion))
-            completionCallbacks[identifier] = callbacks
+            completionCallbacks[callbackKey] = callbacks
             return
         } else {
-            completionCallbacks[identifier] = [CompletionWrapper(completion)]
+            completionCallbacks[callbackKey] = [CompletionWrapper(completion)]
         }
         
         func sampleFileAtURL(_ url: URL, duration: TimeInterval) {
             let analyser = WaveformAnalyzer(audioAssetURL: url)
             analyser?.samples(count: numberOfSamples, completionHandler: { samples in
                 // Dispatch back from the WaveformAnalyzer's internal queue
-                DispatchQueue.main.async {
+                self.workQueue.async {
                     guard let samples = samples else {
                         self.invokeFailureCallbacksForIdentifier(identifier, error: VoiceMessageAttachmentCacheManagerError.samplingError)
                         return

            }
        }
        
        self.completionCallbacks[identifier] = nil
    }
}

    }
}

private struct CompletionCallbackKey: Hashable {
    let eventIdentifier: String
    let requiredNumberOfSamples: Int
}

struct VoiceMessageAttachmentCacheManagerLoadResult {
    let eventIdentifier: String
    let url: URL
