diff --git a/ledger-tool/tests/basic.rs b/ledger-tool/tests/basic.rs
index 4cc02383fa..edae47057c 100644
--- a/ledger-tool/tests/basic.rs
+++ b/ledger-tool/tests/basic.rs
@@ -32,7 +32,7 @@ fn bad_arguments() {
 #[test]
 fn nominal() {
     let keypair = Arc::new(Keypair::new());
-    let (_, ledger_path, _, _) =
+    let (_mint_keypair, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
         create_tmp_sample_ledger("test_ledger_tool_nominal", 100, 9, keypair.pubkey(), 50);
 
     // Basic validation
diff --git a/src/bank.rs b/src/bank.rs
index e02e775e85..719c0bda67 100644
--- a/src/bank.rs
+++ b/src/bank.rs
@@ -817,25 +817,40 @@ impl Bank {
     where
         I: IntoIterator<Item = Entry>,
     {
-        let mut entry_height = 0;
-        let mut last_id = self.last_id();
+        let mut last_entry_id = self.last_id();
+        let mut entries_iter = entries.into_iter();
+
+        trace!("genesis last_id={}", last_entry_id);
+
+        // The first entry in the ledger is a pseudo-tick used only to ensure the number of ticks
+        // in slot 0 is the same as the number of ticks in all subsequent slots.  It is not
+        // registered as a tick and thus cannot be used as a last_id
+        let entry0 = entries_iter
+            .next()
+            .ok_or(BankError::LedgerVerificationFailed)?;
+        if !(entry0.is_tick() && entry0.verify(&last_entry_id)) {
+            warn!("Ledger proof of history failed at entry0");
+            return Err(BankError::LedgerVerificationFailed);
+        }
+        last_entry_id = entry0.id;
+        let mut entry_height = 1;
 
         // Ledger verification needs to be parallelized, but we can't pull the whole
         // thing into memory. We therefore chunk it.
-        for block in &entries.into_iter().chunks(VERIFY_BLOCK_SIZE) {
+        for block in &entries_iter.chunks(VERIFY_BLOCK_SIZE) {
             let block: Vec<_> = block.collect();
 
-            if !block.verify(&last_id) {
+            if !block.verify(&last_entry_id) {
                 warn!("Ledger proof of history failed at entry: {}", entry_height);
                 return Err(BankError::LedgerVerificationFailed);
             }
 
             self.process_block(&block)?;
 
-            last_id = block.last().unwrap().id;
+            last_entry_id = block.last().unwrap().id;
             entry_height += block.len() as u64;
         }
-        Ok((entry_height, last_id))
+        Ok((entry_height, last_entry_id))
     }
 
     /// Create, sign, and process a Transaction from `keypair` to `to` of
@@ -1251,10 +1266,12 @@ mod tests {
     ) -> impl Iterator<Item = Entry> {
         let mut entries: Vec<Entry> = vec![];
 
-        // Start off the ledger with a tick linked to the genesis block
+        let mut last_id = genesis_block.last_id();
+
+        // Start off the ledger with the psuedo-tick linked to the genesis block
+        // (see entry0 in `process_ledger`)
         let tick = Entry::new(&genesis_block.last_id(), 0, 1, vec![]);
         let mut hash = tick.id;
-        let mut last_id = tick.id;
         entries.push(tick);
 
         let num_hashes = 1;
@@ -1281,10 +1298,12 @@ mod tests {
     ) -> impl Iterator<Item = Entry> {
         let mut entries = vec![];
 
-        // Start off the ledger with a tick linked to the genesis block
+        let mut last_id = genesis_block.last_id();
+
+        // Start off the ledger with the psuedo-tick linked to the genesis block
+        // (see entry0 in `process_ledger`)
         let tick = Entry::new(&genesis_block.last_id(), 0, 1, vec![]);
         let mut hash = tick.id;
-        let mut last_id = tick.id;
         entries.push(tick);
 
         for i in 0..num_one_token_transfers {
@@ -1351,7 +1370,7 @@ mod tests {
         let (ledger_height, last_id) = bank.process_ledger(ledger).unwrap();
         assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 100 - 3);
         assert_eq!(ledger_height, 8);
-        assert_eq!(bank.tick_height(), 2);
+        assert_eq!(bank.tick_height(), 1);
         assert_eq!(bank.last_id(), last_id);
     }
 
diff --git a/src/blocktree.rs b/src/blocktree.rs
index f94b99ebab..178f102f59 100644
--- a/src/blocktree.rs
+++ b/src/blocktree.rs
@@ -150,15 +150,7 @@ impl SlotMeta {
             // A placeholder slot does not contain all the ticks
             false
         } else {
-            let num_expected_ticks = {
-                let num = self.num_expected_ticks(blocktree);
-                if self.slot_height == 0 {
-                    num - 1
-                } else {
-                    num
-                }
-            };
-            num_expected_ticks <= self.consumed_ticks
+            self.num_expected_ticks(blocktree) <= self.consumed_ticks
         }
     }
 
@@ -1305,35 +1297,38 @@ pub fn get_tmp_ledger_path(name: &str) -> String {
     path
 }
 
-pub fn create_tmp_ledger(name: &str, genesis_block: &GenesisBlock) -> String {
-    let ledger_path = get_tmp_ledger_path(name);
-    create_new_ledger(&ledger_path, genesis_block).unwrap();
-    ledger_path
-}
-
 pub fn create_tmp_sample_ledger(
     name: &str,
     num_tokens: u64,
     num_extra_ticks: u64,
     bootstrap_leader_id: Pubkey,
     bootstrap_leader_tokens: u64,
-) -> (Keypair, String, u64, Hash) {
+) -> (Keypair, String, u64, Hash, Hash) {
     let (genesis_block, mint_keypair) =
         GenesisBlock::new_with_leader(num_tokens, bootstrap_leader_id, bootstrap_leader_tokens);
     let ledger_path = get_tmp_ledger_path(name);
-    let (mut entry_height, mut last_id) = create_new_ledger(&ledger_path, &genesis_block).unwrap();
+    let (mut entry_height, mut last_entry_id) =
+        create_new_ledger(&ledger_path, &genesis_block).unwrap();
 
+    let mut last_id = genesis_block.last_id();
     if num_extra_ticks > 0 {
-        let entries = crate::entry::create_ticks(num_extra_ticks, last_id);
+        let entries = crate::entry::create_ticks(num_extra_ticks, last_entry_id);
 
         let blocktree = Blocktree::open(&ledger_path).unwrap();
         blocktree
             .write_entries(DEFAULT_SLOT_HEIGHT, entry_height, &entries)
             .unwrap();
         entry_height += entries.len() as u64;
-        last_id = entries.last().unwrap().id
+        last_id = entries.last().unwrap().id;
+        last_entry_id = last_id;
     }
-    (mint_keypair, ledger_path, entry_height, last_id)
+    (
+        mint_keypair,
+        ledger_path,
+        entry_height,
+        last_id,
+        last_entry_id,
+    )
 }
 
 pub fn tmp_copy_ledger(from: &str, name: &str) -> String {
@@ -1992,11 +1987,7 @@ mod tests {
                     assert_eq!(s.next_slots, vec![i + 1]);
                 }
                 assert_eq!(s.num_blocks, 1);
-                if i == 0 {
-                    assert_eq!(s.consumed_ticks, ticks_per_slot - 1);
-                } else {
-                    assert_eq!(s.consumed_ticks, ticks_per_slot);
-                }
+                assert_eq!(s.consumed_ticks, ticks_per_slot);
                 assert!(s.is_trunk);
             }
         }
@@ -2062,11 +2053,7 @@ mod tests {
                 } else {
                     assert!(s.next_slots.is_empty());
                 }
-                if i == 0 {
-                    assert_eq!(s.consumed_ticks, ticks_per_slot - 1);
-                } else {
-                    assert_eq!(s.consumed_ticks, ticks_per_slot);
-                }
+                assert_eq!(s.consumed_ticks, ticks_per_slot);
                 assert!(s.is_trunk);
             }
         }
diff --git a/src/fullnode.rs b/src/fullnode.rs
index 026160cff5..dec008f53c 100644
--- a/src/fullnode.rs
+++ b/src/fullnode.rs
@@ -580,7 +580,7 @@ mod tests {
 
         let validator_keypair = Keypair::new();
         let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
-        let (_, validator_ledger_path, _, _) =
+        let (_mint_keypair, validator_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
             create_tmp_sample_ledger("validator_exit", 10_000, 0, leader_keypair.pubkey(), 1000);
 
         let validator = Fullnode::new(
@@ -605,7 +605,13 @@ mod tests {
             .map(|i| {
                 let validator_keypair = Keypair::new();
                 let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
-                let (_, validator_ledger_path, _, _) = create_tmp_sample_ledger(
+                let (
+                    _mint_keypair,
+                    validator_ledger_path,
+                    _last_entry_height,
+                    _last_id,
+                    _last_entry_id,
+                ) = create_tmp_sample_ledger(
                     &format!("validator_parallel_exit_{}", i),
                     10_000,
                     0,
@@ -645,14 +651,19 @@ mod tests {
         let bootstrap_leader_node =
             Node::new_localhost_with_pubkey(bootstrap_leader_keypair.pubkey());
 
-        let (_mint_keypair, bootstrap_leader_ledger_path, _genesis_entry_height, _last_id) =
-            create_tmp_sample_ledger(
-                "test_leader_to_leader_transition",
-                10_000,
-                1,
-                bootstrap_leader_keypair.pubkey(),
-                500,
-            );
+        let (
+            _mint_keypair,
+            bootstrap_leader_ledger_path,
+            _genesis_entry_height,
+            _last_id,
+            _last_entry_id,
+        ) = create_tmp_sample_ledger(
+            "test_leader_to_leader_transition",
+            10_000,
+            1,
+            bootstrap_leader_keypair.pubkey(),
+            500,
+        );
 
         // Once the bootstrap leader hits the second epoch, because there are no other choices in
         // the active set, this leader will remain the leader in the second epoch. In the second
@@ -1018,13 +1029,14 @@ mod tests {
 
         // Create validator identity
         assert!(num_genesis_ticks <= ticks_per_block);
-        let (mint_keypair, ledger_path, genesis_entry_height, last_id) = create_tmp_sample_ledger(
-            test_name,
-            10_000,
-            num_genesis_ticks,
-            leader_node.info.id,
-            500,
-        );
+        let (mint_keypair, ledger_path, genesis_entry_height, last_id, last_entry_id) =
+            create_tmp_sample_ledger(
+                test_name,
+                10_000,
+                num_genesis_ticks,
+                leader_node.info.id,
+                500,
+            );
 
         let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
 
@@ -1040,7 +1052,7 @@ mod tests {
             &mint_keypair,
             10,
             1,
-            &last_id,
+            &last_entry_id,
             &last_id,
             num_ending_ticks,
         );
diff --git a/src/replay_stage.rs b/src/replay_stage.rs
index 9690c37dec..97fdc57f68 100644
--- a/src/replay_stage.rs
+++ b/src/replay_stage.rs
@@ -87,6 +87,7 @@ impl ReplayStage {
         let mut res = Ok(());
         let mut num_entries_to_write = entries.len();
         let now = Instant::now();
+
         if !entries.as_slice().verify(&last_entry_id.read().unwrap()) {
             inc_new_counter_info!("replicate_stage-verify-fail", entries.len());
             return Err(Error::BlobError(BlobError::VerificationFailed));
@@ -411,7 +412,7 @@ mod test {
         let old_leader_id = Keypair::new().pubkey();
 
         // Create a ledger
-        let (mint_keypair, my_ledger_path, genesis_entry_height, mut last_id) =
+        let (mint_keypair, my_ledger_path, genesis_entry_height, mut last_id, last_entry_id) =
             create_tmp_sample_ledger(
                 "test_replay_stage_leader_rotation_exit",
                 10_000,
@@ -433,7 +434,7 @@ mod test {
             &mint_keypair,
             100,
             ticks_per_slot, // add a vote for tick_height = ticks_per_slot
-            &last_id,
+            &last_entry_id,
             &last_id,
             0,
         );
@@ -538,13 +539,14 @@ mod test {
         // Create keypair for the leader
         let leader_id = Keypair::new().pubkey();
 
-        let (_, my_ledger_path, _, _) = create_tmp_sample_ledger(
-            "test_vote_error_replay_stage_correctness",
-            10_000,
-            1,
-            leader_id,
-            500,
-        );
+        let (_mint_keypair, my_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
+            create_tmp_sample_ledger(
+                "test_vote_error_replay_stage_correctness",
+                10_000,
+                1,
+                leader_id,
+                500,
+            );
 
         // Set up the cluster info
         let cluster_info_me = Arc::new(RwLock::new(ClusterInfo::new(my_node.info.clone())));
@@ -583,7 +585,7 @@ mod test {
             let vote = VoteTransaction::new_vote(keypair, bank.tick_height(), bank.last_id(), 0);
             cluster_info_me.write().unwrap().push_vote(vote);
 
-            // Send ReplayStage an entry, should see it on the ledger writer receiver
+            info!("Send ReplayStage an entry, should see it on the ledger writer receiver");
             let next_tick = create_ticks(1, last_entry_id);
 
             blocktree
@@ -592,7 +594,7 @@ mod test {
 
             let received_tick = ledger_writer_recv
                 .recv()
-                .expect("Expected to recieve an entry on the ledger writer receiver");
+                .expect("Expected to receive an entry on the ledger writer receiver");
 
             assert_eq!(next_tick, received_tick);
 
@@ -617,7 +619,7 @@ mod test {
         let leader_id = Keypair::new().pubkey();
 
         // Create the ledger
-        let (mint_keypair, my_ledger_path, genesis_entry_height, last_id) =
+        let (mint_keypair, my_ledger_path, genesis_entry_height, last_id, last_entry_id) =
             create_tmp_sample_ledger(
                 "test_vote_error_replay_stage_leader_rotation",
                 10_000,
@@ -630,8 +632,15 @@ mod test {
         // Write two entries to the ledger so that the validator is in the active set:
         // 1) Give the validator a nonzero number of tokens 2) A vote from the validator.
         // This will cause leader rotation after the bootstrap height
-        let (active_set_entries, voting_keypair) =
-            make_active_set_entries(&my_keypair, &mint_keypair, 100, 1, &last_id, &last_id, 0);
+        let (active_set_entries, voting_keypair) = make_active_set_entries(
+            &my_keypair,
+            &mint_keypair,
+            100,
+            1,
+            &last_entry_id,
+            &last_id,
+            0,
+        );
         let mut last_id = active_set_entries.last().unwrap().id;
         let initial_tick_height = genesis_entry_height;
 
diff --git a/src/storage_stage.rs b/src/storage_stage.rs
index 3081c31994..a87964eb16 100644
--- a/src/storage_stage.rs
+++ b/src/storage_stage.rs
@@ -492,13 +492,14 @@ mod tests {
         let keypair = Arc::new(Keypair::new());
         let exit = Arc::new(AtomicBool::new(false));
 
-        let (_mint, ledger_path, genesis_entry_height, _last_id) = create_tmp_sample_ledger(
-            "storage_stage_process_entries",
-            1000,
-            1,
-            Keypair::new().pubkey(),
-            1,
-        );
+        let (_mint, ledger_path, genesis_entry_height, _last_id, _last_entry_id) =
+            create_tmp_sample_ledger(
+                "storage_stage_process_entries",
+                1000,
+                1,
+                Keypair::new().pubkey(),
+                1,
+            );
 
         let entries = make_tiny_test_entries(64);
         let blocktree = Blocktree::open(&ledger_path).unwrap();
@@ -560,13 +561,14 @@ mod tests {
         let keypair = Arc::new(Keypair::new());
         let exit = Arc::new(AtomicBool::new(false));
 
-        let (_mint, ledger_path, genesis_entry_height, _last_id) = create_tmp_sample_ledger(
-            "storage_stage_process_entries",
-            1000,
-            1,
-            Keypair::new().pubkey(),
-            1,
-        );
+        let (_mint, ledger_path, genesis_entry_height, _last_id, _last_entry_id) =
+            create_tmp_sample_ledger(
+                "storage_stage_process_entries",
+                1000,
+                1,
+                Keypair::new().pubkey(),
+                1,
+            );
 
         let entries = make_tiny_test_entries(128);
         let blocktree = Blocktree::open(&ledger_path).unwrap();
diff --git a/src/thin_client.rs b/src/thin_client.rs
index 8b59e3ffb8..ae19ff5616 100644
--- a/src/thin_client.rs
+++ b/src/thin_client.rs
@@ -464,7 +464,7 @@ pub fn new_fullnode(ledger_name: &'static str) -> (Fullnode, NodeInfo, Keypair,
     let node = Node::new_localhost_with_pubkey(node_keypair.pubkey());
     let node_info = node.info.clone();
 
-    let (mint_keypair, ledger_path, _, _) =
+    let (mint_keypair, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
         create_tmp_sample_ledger(ledger_name, 10_000, 0, node_info.id, 42);
 
     let vote_account_keypair = Arc::new(Keypair::new());
diff --git a/tests/multinode.rs b/tests/multinode.rs
index b6825a15ba..18a4ad9242 100644
--- a/tests/multinode.rs
+++ b/tests/multinode.rs
@@ -44,7 +44,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
     let bob_pubkey = Keypair::new().pubkey();
     let mut ledger_paths = Vec::new();
 
-    let (alice, leader_ledger_path, mut last_entry_height, mut last_entry_id) =
+    let (alice, leader_ledger_path, mut last_entry_height, _last_id, mut last_entry_id) =
         create_tmp_sample_ledger("multi_node_ledger_window", 10_000, 0, leader_data.id, 500);
     ledger_paths.push(leader_ledger_path.clone());
 
@@ -65,7 +65,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
         let blocktree = Blocktree::open(&leader_ledger_path).unwrap();
 
         let entries = solana::entry::create_ticks(
-            fullnode_config.leader_scheduler_config.ticks_per_slot - last_entry_height - 2,
+            fullnode_config.leader_scheduler_config.ticks_per_slot - last_entry_height - 1,
             last_entry_id,
         );
         blocktree
@@ -164,13 +164,14 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
     let bob_pubkey = Keypair::new().pubkey();
     let mut ledger_paths = Vec::new();
 
-    let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger(
-        "multi_node_validator_catchup_from_zero",
-        10_000,
-        0,
-        leader_data.id,
-        500,
-    );
+    let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
+        create_tmp_sample_ledger(
+            "multi_node_validator_catchup_from_zero",
+            10_000,
+            0,
+            leader_data.id,
+            500,
+        );
     ledger_paths.push(genesis_ledger_path.clone());
 
     let zero_ledger_path = tmp_copy_ledger(
@@ -353,7 +354,7 @@ fn test_multi_node_basic() {
     let bob_pubkey = Keypair::new().pubkey();
     let mut ledger_paths = Vec::new();
 
-    let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) =
+    let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
         create_tmp_sample_ledger("multi_node_basic", 10_000, 0, leader_data.id, 500);
     ledger_paths.push(genesis_ledger_path.clone());
 
@@ -453,7 +454,7 @@ fn test_boot_validator_from_file() -> result::Result<()> {
     let bob_pubkey = Keypair::new().pubkey();
     let mut ledger_paths = Vec::new();
 
-    let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) =
+    let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
         create_tmp_sample_ledger("boot_validator_from_file", 100_000, 0, leader_pubkey, 1000);
     ledger_paths.push(genesis_ledger_path.clone());
 
@@ -532,13 +533,14 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
 
     let leader_keypair = Arc::new(Keypair::new());
     let initial_leader_balance = 500;
-    let (alice, ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger(
-        "leader_restart_validator_start_from_old_ledger",
-        100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64,
-        0,
-        leader_keypair.pubkey(),
-        initial_leader_balance,
-    );
+    let (alice, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
+        create_tmp_sample_ledger(
+            "leader_restart_validator_start_from_old_ledger",
+            100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64,
+            0,
+            leader_keypair.pubkey(),
+            initial_leader_balance,
+        );
     let bob_pubkey = Keypair::new().pubkey();
 
     {
@@ -641,13 +643,14 @@ fn test_multi_node_dynamic_network() {
     let leader_pubkey = leader_keypair.pubkey().clone();
     let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
     let bob_pubkey = Keypair::new().pubkey();
-    let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger(
-        "multi_node_dynamic_network",
-        10_000_000,
-        0,
-        leader_pubkey,
-        500,
-    );
+    let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
+        create_tmp_sample_ledger(
+            "multi_node_dynamic_network",
+            10_000_000,
+            0,
+            leader_pubkey,
+            500,
+        );
 
     let mut ledger_paths = Vec::new();
     ledger_paths.push(genesis_ledger_path.clone());
@@ -862,7 +865,7 @@ fn test_leader_to_validator_transition() {
 
     // Initialize the leader ledger. Make a mint and a genesis entry
     // in the leader ledger
-    let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id) =
+    let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id, last_entry_id) =
         create_tmp_sample_ledger(
             "test_leader_to_validator_transition",
             10_000,
@@ -878,7 +881,7 @@ fn test_leader_to_validator_transition() {
         &mint_keypair,
         100,
         ticks_per_slot,
-        &last_id,
+        &last_entry_id,
         &last_id,
         0,
     );
@@ -963,7 +966,7 @@ fn test_leader_validator_basic() {
     info!("validator id: {}", validator_keypair.pubkey());
 
     // Make a common mint and a genesis entry for both leader + validator ledgers
-    let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id) =
+    let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id, last_entry_id) =
         create_tmp_sample_ledger(
             "test_leader_validator_basic",
             10_000,
@@ -978,7 +981,7 @@ fn test_leader_validator_basic() {
         &mint_keypair,
         100,
         1,
-        &last_id,
+        &last_entry_id,
         &last_id,
         0,
     );
@@ -1036,30 +1039,40 @@ fn test_leader_validator_basic() {
 
     converge(&leader_info, 2);
 
-    info!("Waiting for slot 0 -> slot 1: bootstrap leader will remain the leader");
-    assert_eq!(
-        leader_rotation_receiver.recv().unwrap(),
-        (FullnodeReturnType::LeaderToLeaderRotation, ticks_per_slot,)
-    );
-
-    info!("Waiting for slot 1 -> slot 2: bootstrap leader becomes a validator");
+    info!("Waiting for slot 0 -> slot 1: bootstrap leader and the validator rotate");
     assert_eq!(
         leader_rotation_receiver.recv().unwrap(),
         (
             FullnodeReturnType::LeaderToValidatorRotation,
-            ticks_per_slot * 2,
+            ticks_per_slot,
         )
     );
-
-    info!("Waiting for slot 1 -> slot 2: validator becomes the leader");
     assert_eq!(
         validator_rotation_receiver.recv().unwrap(),
         (
             FullnodeReturnType::ValidatorToLeaderRotation,
+            ticks_per_slot,
+        )
+    );
+
+    info!("Waiting for slot 1 -> slot 2: validator remains the slot leader due to no votes");
+    assert_eq!(
+        validator_rotation_receiver.recv().unwrap(),
+        (
+            FullnodeReturnType::LeaderToLeaderRotation,
             ticks_per_slot * 2,
         )
     );
 
+    info!("Waiting for slot 2 -> slot 3: validator remains the slot leader due to no votes");
+    assert_eq!(
+        validator_rotation_receiver.recv().unwrap(),
+        (
+            FullnodeReturnType::LeaderToLeaderRotation,
+            ticks_per_slot * 3,
+        )
+    );
+
     info!("Shut down");
     validator_exit();
     leader_exit();
@@ -1109,7 +1122,7 @@ fn test_dropped_handoff_recovery() {
 
     // Make a common mint and a genesis entry for both leader + validator's ledgers
     let num_ending_ticks = 1;
-    let (mint_keypair, genesis_ledger_path, genesis_entry_height, last_id) =
+    let (mint_keypair, genesis_ledger_path, genesis_entry_height, last_id, last_entry_id) =
         create_tmp_sample_ledger(
             "test_dropped_handoff_recovery",
             10_000,
@@ -1134,7 +1147,7 @@ fn test_dropped_handoff_recovery() {
         &mint_keypair,
         100,
         ticks_per_slot,
-        &last_id,
+        &last_entry_id,
         &last_id,
         0,
     );
@@ -1268,17 +1281,19 @@ fn test_full_leader_validator_network() {
 
     // Make a common mint and a genesis entry for both leader + validator's ledgers
     let num_ending_ticks = 1;
-    let (mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, last_id) =
-        create_tmp_sample_ledger(
-            "test_full_leader_validator_network",
-            10_000,
-            num_ending_ticks,
-            bootstrap_leader_info.id,
-            500,
-        );
-
-    let last_tick_id = last_id;
-    let mut last_entry_id = last_id;
+    let (
+        mint_keypair,
+        bootstrap_leader_ledger_path,
+        genesis_entry_height,
+        last_id,
+        mut last_entry_id,
+    ) = create_tmp_sample_ledger(
+        "test_full_leader_validator_network",
+        10_000,
+        num_ending_ticks,
+        bootstrap_leader_info.id,
+        500,
+    );
 
     // Create a common ledger with entries in the beginnging that will add all the validators
     // to the active set for leader election.
@@ -1295,7 +1310,7 @@ fn test_full_leader_validator_network() {
             100,
             1,
             &last_entry_id,
-            &last_tick_id,
+            &last_id,
             0,
         );
 
@@ -1475,14 +1490,19 @@ fn test_broadcast_last_tick() {
     let bootstrap_leader_info = bootstrap_leader_node.info.clone();
 
     // Create leader ledger
-    let (_mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, _last_id) =
-        create_tmp_sample_ledger(
-            "test_broadcast_last_tick",
-            10_000,
-            0,
-            bootstrap_leader_info.id,
-            500,
-        );
+    let (
+        _mint_keypair,
+        bootstrap_leader_ledger_path,
+        genesis_entry_height,
+        _last_id,
+        _last_entry_id,
+    ) = create_tmp_sample_ledger(
+        "test_broadcast_last_tick",
+        10_000,
+        0,
+        bootstrap_leader_info.id,
+        500,
+    );
 
     let genesis_ledger_len = genesis_entry_height;
     debug!("genesis_ledger_len: {}", genesis_ledger_len);
@@ -1550,7 +1570,7 @@ fn test_broadcast_last_tick() {
     bootstrap_leader_exit();
 
     // Index of the last tick must be at least ticks_per_slot - 1
-    let last_tick_entry_index = ticks_per_slot as usize - 2;
+    let last_tick_entry_index = ticks_per_slot as usize - 1;
     let entries = read_ledger(&bootstrap_leader_ledger_path);
     assert!(entries.len() >= last_tick_entry_index + 1);
     let expected_last_tick = &entries[last_tick_entry_index];
diff --git a/tests/replicator.rs b/tests/replicator.rs
index d26bca6d08..53b8bf35d4 100644
--- a/tests/replicator.rs
+++ b/tests/replicator.rs
@@ -40,7 +40,7 @@ fn test_replicator_startup_basic() {
     let leader_info = leader_node.info.clone();
 
     let leader_ledger_path = "replicator_test_leader_ledger";
-    let (mint_keypair, leader_ledger_path, _last_entry_height, _last_entry_id) =
+    let (mint_keypair, leader_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
         create_tmp_sample_ledger(leader_ledger_path, 1_000_000_000, 0, leader_info.id, 42);
 
     let validator_ledger_path =
@@ -277,7 +277,7 @@ fn test_replicator_startup_ledger_hang() {
     let leader_info = leader_node.info.clone();
 
     let leader_ledger_path = "replicator_test_leader_ledger";
-    let (_mint_keypair, leader_ledger_path, _last_entry_height, _last_entry_id) =
+    let (_mint_keypair, leader_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
         create_tmp_sample_ledger(leader_ledger_path, 100, 0, leader_info.id, 42);
 
     let validator_ledger_path =