diff --git a/beacon_node/client/src/builder.rs b/beacon_node/client/src/builder.rs
index 59f1bebdb4..1f02ec7b3c 100644
--- a/beacon_node/client/src/builder.rs
+++ b/beacon_node/client/src/builder.rs
@@ -485,13 +485,8 @@ where
             .beacon_chain
             .clone()
             .ok_or("node timer requires a beacon chain")?;
-        let seconds_per_slot = self
-            .chain_spec
-            .as_ref()
-            .ok_or("node timer requires a chain spec")?
-            .seconds_per_slot;
 
-        spawn_timer(context.executor, beacon_chain, seconds_per_slot)
+        spawn_timer(context.executor, beacon_chain)
             .map_err(|e| format!("Unable to start node timer: {}", e))?;
 
         Ok(self)
diff --git a/beacon_node/timer/src/lib.rs b/beacon_node/timer/src/lib.rs
index 9c6bf1ca87..bf2acaf5bb 100644
--- a/beacon_node/timer/src/lib.rs
+++ b/beacon_node/timer/src/lib.rs
@@ -6,29 +6,29 @@ use beacon_chain::{BeaconChain, BeaconChainTypes};
 use slog::{debug, info, warn};
 use slot_clock::SlotClock;
 use std::sync::Arc;
-use std::time::Duration;
-use tokio::time::{interval_at, Instant};
+use tokio::time::sleep;
 
 /// Spawns a timer service which periodically executes tasks for the beacon chain
 pub fn spawn_timer<T: BeaconChainTypes>(
     executor: task_executor::TaskExecutor,
     beacon_chain: Arc<BeaconChain<T>>,
-    seconds_per_slot: u64,
 ) -> Result<(), &'static str> {
     let log = executor.log();
-    let start_instant = Instant::now()
-        + beacon_chain
-            .slot_clock
-            .duration_to_next_slot()
-            .ok_or("slot_notifier unable to determine time to next slot")?;
-
-    // Warning: `interval_at` panics if `seconds_per_slot` = 0.
-    let mut interval = interval_at(start_instant, Duration::from_secs(seconds_per_slot));
     let per_slot_executor = executor.clone();
+
     let timer_future = async move {
         let log = per_slot_executor.log().clone();
         loop {
-            interval.tick().await;
+            let duration_to_next_slot = match beacon_chain.slot_clock.duration_to_next_slot() {
+                Some(duration) => duration,
+                None => {
+                    warn!(log, "Unable to determine duration to next slot");
+                    return;
+                }
+            };
+
+            sleep(duration_to_next_slot).await;
+
             let chain = beacon_chain.clone();
             if let Some(handle) = per_slot_executor
                 .spawn_blocking_handle(move || chain.per_slot_task(), "timer_per_slot_task")