diff --git a/src/index.js b/src/index.js
index 49eb1bf..731f38c 100644
--- a/src/index.js
+++ b/src/index.js
@@ -2,6 +2,7 @@ import createDeferred from './external/p-defer';
 
 export default class EventAsPromise {
   constructor(options = {}) {
+    this.queue = [];
     this.defers = [];
     this.upcomingDeferred = null;
     this.eventListener = this.eventListener.bind(this);
@@ -22,7 +23,13 @@ export default class EventAsPromise {
     const deferred = this.defers.shift();
     const args = this.options.array ? [].slice.call(arguments) : event;
 
-    deferred && deferred.resolve(args);
+    if (deferred) {
+      deferred.resolve(args);
+    } else if (this.options.queue) {
+      const newDeferred = createDeferred();
+      newDeferred.resolve(args);
+      this.queue.push(newDeferred.promise);
+    }
 
     if (this.upcomingDeferred) {
       this.upcomingDeferred.resolve(args);
@@ -31,6 +38,10 @@ export default class EventAsPromise {
   }
 
   one() {
+    if (this.options.queue && this.queue.length > 0) {
+      return this.queue.shift();
+    }
+
     const deferred = createDeferred();
 
     this.defers.push(deferred);
diff --git a/src/index.spec.js b/src/index.spec.js
index 2ddecd6..4e4983c 100644
--- a/src/index.spec.js
+++ b/src/index.spec.js
@@ -37,6 +37,29 @@ test('no backlog', async () => {
   await expect(upcomingPromise).resolves.toBe(2);
 });
 
+test('with backlog', async () => {
+  const eventAsPromise = new EventAsPromise({ queue: true });
+  const emitter = new EventEmitter();
+
+  emitter.on('count', eventAsPromise.eventListener);
+  emitter.emit('count', 1);
+
+  const promise1 = eventAsPromise.one();
+  const promise2 = eventAsPromise.one();
+  const upcomingPromise = eventAsPromise.upcoming();
+
+  emitter.emit('count', 2);
+
+  await expect(hasResolved(promise1)).resolves.toBeTruthy();
+  await expect(promise1).resolves.toBe(1);
+
+  await expect(hasResolved(promise2)).resolves.toBeTruthy();
+  await expect(promise2).resolves.toBe(2);
+
+  await expect(hasResolved(upcomingPromise)).resolves.toBeTruthy();
+  await expect(upcomingPromise).resolves.toBe(2);
+});
+
 test('repeated', async () => {
   const eventAsPromise = new EventAsPromise();
   const emitter = new EventEmitter();