diff --git a/src/core/timer_queue.cpp b/src/core/timer_queue.cpp
index d079ec7..5044c26 100644
--- a/src/core/timer_queue.cpp
+++ b/src/core/timer_queue.cpp
@@ -12,10 +12,10 @@
 #include <algorithm>
 #include <forward_list>
 
+#include <disruptorplus/blocking_wait_strategy.hpp>
 #include <disruptorplus/multi_threaded_claim_strategy.hpp>
 #include <disruptorplus/ring_buffer.hpp>
 #include <disruptorplus/sequence_barrier.hpp>
-#include <disruptorplus/spin_wait_strategy.hpp>
 
 #include <rex/assert.h>
 #include <rex/thread.h>
@@ -142,9 +142,15 @@ class TimerQueue {
   // This ring buffer will be used to introduce timers queued by the public API
   static constexpr size_t kWaitCount = 512;
   dp::ring_buffer<std::shared_ptr<WaitItem>> buffer_;
-  dp::spin_wait_strategy wait_strategy_;
-  dp::multi_threaded_claim_strategy<dp::spin_wait_strategy> claim_strategy_;
-  dp::sequence_barrier<dp::spin_wait_strategy> consumed_;
+  // Blocking (condition-variable) waits, not the spin strategy: the dispatch
+  // thread waits with a deadline of the next timer due time, and with a spin
+  // strategy that wait yield-spins for the whole interval, permanently
+  // burning most of a core while any guest timer is pending. Guest timers
+  // need millisecond-class dispatch precision, which a condition variable
+  // delivers comfortably.
+  dp::blocking_wait_strategy wait_strategy_;
+  dp::multi_threaded_claim_strategy<dp::blocking_wait_strategy> claim_strategy_;
+  dp::sequence_barrier<dp::blocking_wait_strategy> consumed_;
 
   // This is a _sorted_ (ascending due_) list of active timers managed by a
   // dedicated thread
diff --git a/thirdparty/disruptorplus/include/disruptorplus/blocking_wait_strategy.hpp b/thirdparty/disruptorplus/include/disruptorplus/blocking_wait_strategy.hpp
index 32d427d..23fd3e1 100644
--- a/thirdparty/disruptorplus/include/disruptorplus/blocking_wait_strategy.hpp
+++ b/thirdparty/disruptorplus/include/disruptorplus/blocking_wait_strategy.hpp
@@ -118,11 +118,11 @@ namespace disruptorplus
                 std::unique_lock<std::mutex> lock(m_mutex);
                 m_cv.wait_for(
                     lock,
+                    timeout,
                     [&]() -> bool {
                         result = minimum_sequence_after(sequence, count, sequences);
                         return difference(result, sequence) >= 0;
-                    },
-                    timeout);
+                    });
             }
             return result;
         }
@@ -171,11 +171,11 @@ namespace disruptorplus
                 std::unique_lock<std::mutex> lock(m_mutex);
                 m_cv.wait_until(
                     lock,
+                    timeoutTime,
                     [&]() -> bool {
                         result = minimum_sequence_after(sequence, count, sequences);
                         return difference(result, sequence) >= 0;
-                    },
-                    timeoutTime);
+                    });
             }
             return result;
         }