diff --git a/core/src/cluster_info_vote_listener.rs b/core/src/cluster_info_vote_listener.rs
index 5b75a2593e..87f6c02777 100644
--- a/core/src/cluster_info_vote_listener.rs
+++ b/core/src/cluster_info_vote_listener.rs
@@ -1146,9 +1146,7 @@ mod tests {
         // Create the set of relevant voters for the next epoch
         let new_epoch = last_known_epoch + 1;
         let first_slot_in_new_epoch = bank.epoch_schedule().get_first_slot_in_epoch(new_epoch);
-        let new_keypairs: Vec<_> = (0..10)
-            .map(|_| ValidatorVoteKeypairs::new(Keypair::new(), Keypair::new(), Keypair::new()))
-            .collect();
+        let new_keypairs: Vec<_> = (0..10).map(|_| ValidatorVoteKeypairs::new_rand()).collect();
         let new_epoch_authorized_voters: HashMap<_, _> = new_keypairs
             .iter()
             .chain(validator_voting_keypairs[0..5].iter())
@@ -1187,15 +1185,14 @@ mod tests {
         let ref_count_per_vote = 2;
 
         // Create some voters at genesis
-        let validator_keypairs: Vec<_> = (0..2)
-            .map(|_| ValidatorVoteKeypairs::new(Keypair::new(), Keypair::new(), Keypair::new()))
-            .collect();
+        let validator_keypairs: Vec<_> =
+            (0..2).map(|_| ValidatorVoteKeypairs::new_rand()).collect();
 
         let GenesisConfigInfo { genesis_config, .. } =
             genesis_utils::create_genesis_config_with_vote_accounts(
                 10_000,
                 &validator_keypairs,
-                100,
+                vec![100; validator_keypairs.len()],
             );
         let bank = Bank::new(&genesis_config);
         let exit = Arc::new(AtomicBool::new(false));
@@ -1336,14 +1333,13 @@ mod tests {
         Vec<ValidatorVoteKeypairs>,
         Arc<RpcSubscriptions>,
     ) {
-        let validator_voting_keypairs: Vec<_> = (0..10)
-            .map(|_| ValidatorVoteKeypairs::new(Keypair::new(), Keypair::new(), Keypair::new()))
-            .collect();
+        let validator_voting_keypairs: Vec<_> =
+            (0..10).map(|_| ValidatorVoteKeypairs::new_rand()).collect();
         let GenesisConfigInfo { genesis_config, .. } =
             genesis_utils::create_genesis_config_with_vote_accounts(
                 10_000,
                 &validator_voting_keypairs,
-                100,
+                vec![100; validator_voting_keypairs.len()],
             );
         let bank = Bank::new(&genesis_config);
         let vote_tracker = VoteTracker::new(&bank);
diff --git a/core/src/commitment_service.rs b/core/src/commitment_service.rs
index 2f37b9f09b..609f12b97c 100644
--- a/core/src/commitment_service.rs
+++ b/core/src/commitment_service.rs
@@ -513,7 +513,11 @@ mod tests {
                 genesis_config,
                 mint_keypair,
                 voting_keypair: _,
-            } = create_genesis_config_with_vote_accounts(1_000_000_000, &validator_keypairs, 100);
+            } = create_genesis_config_with_vote_accounts(
+                1_000_000_000,
+                &validator_keypairs,
+                vec![100; validator_keypairs.len()],
+            );
 
             let node_keypair = Keypair::from_bytes(&node_keypair).unwrap();
             let vote_keypair = Keypair::from_bytes(&vote_keypair).unwrap();
diff --git a/core/src/consensus.rs b/core/src/consensus.rs
index 2ea0ff010a..261426180b 100644
--- a/core/src/consensus.rs
+++ b/core/src/consensus.rs
@@ -676,12 +676,7 @@ pub mod test {
             create_genesis_config_with_vote_accounts, GenesisConfigInfo, ValidatorVoteKeypairs,
         },
     };
-    use solana_sdk::{
-        clock::Slot,
-        hash::Hash,
-        pubkey::Pubkey,
-        signature::{Keypair, Signer},
-    };
+    use solana_sdk::{clock::Slot, hash::Hash, pubkey::Pubkey, signature::Signer};
     use solana_vote_program::{
         vote_state::{Vote, VoteStateVersions, MAX_LOCKOUT_HISTORY},
         vote_transaction,
@@ -936,14 +931,8 @@ pub mod test {
             HeaviestSubtreeForkChoice,
         ) {
             let keypairs: HashMap<_, _> = std::iter::repeat_with(|| {
-                let node_keypair = Keypair::new();
-                let vote_keypair = Keypair::new();
-                let stake_keypair = Keypair::new();
-                let node_pubkey = node_keypair.pubkey();
-                (
-                    node_pubkey,
-                    ValidatorVoteKeypairs::new(node_keypair, vote_keypair, stake_keypair),
-                )
+                let vote_keypairs = ValidatorVoteKeypairs::new_rand();
+                (vote_keypairs.node_keypair.pubkey(), vote_keypairs)
             })
             .take(num_keypairs)
             .collect();
@@ -979,7 +968,11 @@ pub mod test {
             genesis_config,
             mint_keypair,
             voting_keypair: _,
-        } = create_genesis_config_with_vote_accounts(1_000_000_000, &validator_keypairs, stake);
+        } = create_genesis_config_with_vote_accounts(
+            1_000_000_000,
+            &validator_keypairs,
+            vec![stake; validator_keypairs.len()],
+        );
 
         let bank0 = Bank::new(&genesis_config);
 
diff --git a/core/src/progress_map.rs b/core/src/progress_map.rs
index 70e5c874ab..c60174a776 100644
--- a/core/src/progress_map.rs
+++ b/core/src/progress_map.rs
@@ -167,7 +167,7 @@ impl ForkProgress {
         num_dropped_blocks_on_fork: u64,
     ) -> Self {
         let validator_fork_info = {
-            if bank.collector_id() == my_pubkey {
+            if bank.collector_id() == my_pubkey && bank.slot() > 0 {
                 let stake = bank.epoch_vote_account_stake(voting_pubkey);
                 Some(ValidatorStakeInfo::new(
                     *voting_pubkey,
diff --git a/core/src/repair_service.rs b/core/src/repair_service.rs
index ca70529941..341faad56c 100644
--- a/core/src/repair_service.rs
+++ b/core/src/repair_service.rs
@@ -1082,7 +1082,7 @@ mod test {
         } = genesis_utils::create_genesis_config_with_vote_accounts(
             1_000_000_000,
             &[&keypairs],
-            10000,
+            vec![10000],
         );
         let bank0 = Arc::new(Bank::new(&genesis_config));
         let bank9 = Bank::new_from_parent(&bank0, &Pubkey::default(), duplicate_slot);
@@ -1144,7 +1144,7 @@ mod test {
             genesis_utils::create_genesis_config_with_vote_accounts(
                 1_000_000_000,
                 &[keypairs],
-                100,
+                vec![100],
             );
         let bank0 = Bank::new(&genesis_config);
 
diff --git a/core/src/repair_weight.rs b/core/src/repair_weight.rs
index 3c71ede347..8b9094821b 100644
--- a/core/src/repair_weight.rs
+++ b/core/src/repair_weight.rs
@@ -511,6 +511,7 @@ mod test {
     use super::*;
     use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
     use solana_runtime::{bank::Bank, bank_utils};
+    use solana_sdk::hash::Hash;
     use trees::tr;
 
     #[test]
@@ -658,7 +659,7 @@ mod test {
         assert_eq!(repair_weight.trees.get(&8).unwrap().ancestors(10), vec![8]);
 
         // Connect orphan back to main fork
-        blockstore.add_tree(tr(6) / (tr(8)), true, true);
+        blockstore.add_tree(tr(6) / (tr(8)), true, true, 2, Hash::default());
         assert_eq!(
             AncestorIterator::new(8, &blockstore).collect::<Vec<_>>(),
             vec![6, 5, 3, 1, 0]
@@ -742,8 +743,8 @@ mod test {
         assert!(repair_weight.trees.contains_key(&20));
 
         // Resolve orphans in blockstore
-        blockstore.add_tree(tr(6) / (tr(8)), true, true);
-        blockstore.add_tree(tr(11) / (tr(20)), true, true);
+        blockstore.add_tree(tr(6) / (tr(8)), true, true, 2, Hash::default());
+        blockstore.add_tree(tr(11) / (tr(20)), true, true, 2, Hash::default());
         // Call `update_orphan_ancestors` to resolve orphan
         repair_weight.update_orphan_ancestors(
             &blockstore,
@@ -853,8 +854,8 @@ mod test {
         // Resolve the orphans, should now return no
         // orphans
         repairs = vec![];
-        blockstore.add_tree(tr(6) / (tr(8)), true, true);
-        blockstore.add_tree(tr(11) / (tr(20)), true, true);
+        blockstore.add_tree(tr(6) / (tr(8)), true, true, 2, Hash::default());
+        blockstore.add_tree(tr(11) / (tr(20)), true, true, 2, Hash::default());
         repair_weight.get_best_orphans(
             &blockstore,
             &mut repairs,
@@ -889,7 +890,7 @@ mod test {
         // orphan in the `trees` map, we should search for
         // exactly one more of the remaining two
         let mut repairs = vec![];
-        blockstore.add_tree(tr(100) / (tr(101)), true, true);
+        blockstore.add_tree(tr(100) / (tr(101)), true, true, 2, Hash::default());
         repair_weight.get_best_orphans(
             &blockstore,
             &mut repairs,
@@ -991,7 +992,7 @@ mod test {
 
         // Chain orphan 8 back to the main fork, but don't
         // touch orphan 20
-        blockstore.add_tree(tr(4) / (tr(8)), true, true);
+        blockstore.add_tree(tr(4) / (tr(8)), true, true, 2, Hash::default());
 
         // Call `update_orphan_ancestors` to resolve orphan
         repair_weight.update_orphan_ancestors(
@@ -1061,10 +1062,10 @@ mod test {
             }
 
             // Chain orphan 8 back to slot `old_parent`
-            blockstore.add_tree(tr(*old_parent) / (tr(8)), true, true);
+            blockstore.add_tree(tr(*old_parent) / (tr(8)), true, true, 2, Hash::default());
 
             // Chain orphan 20 back to orphan 8
-            blockstore.add_tree(tr(8) / (tr(20)), true, true);
+            blockstore.add_tree(tr(8) / (tr(20)), true, true, 2, Hash::default());
 
             // Call `update_orphan_ancestors` to resolve orphan
             repair_weight.update_orphan_ancestors(
@@ -1089,7 +1090,13 @@ mod test {
 
             // Add a vote that chains back to `old_parent`, should be purged
             let new_vote_slot = 100;
-            blockstore.add_tree(tr(*old_parent) / tr(new_vote_slot), true, true);
+            blockstore.add_tree(
+                tr(*old_parent) / tr(new_vote_slot),
+                true,
+                true,
+                2,
+                Hash::default(),
+            );
             repair_weight.add_votes(
                 &blockstore,
                 vec![(new_vote_slot, vec![Pubkey::default()])].into_iter(),
@@ -1137,7 +1144,7 @@ mod test {
         );
 
         // Ancestors of slot 31 are [30], with no existing subtree
-        blockstore.add_tree(tr(30) / (tr(31)), true, true);
+        blockstore.add_tree(tr(30) / (tr(31)), true, true, 2, Hash::default());
         assert_eq!(
             repair_weight.find_ancestor_subtree_of_slot(&blockstore, 31),
             (vec![30].into_iter().collect::<VecDeque<_>>(), None)
@@ -1155,7 +1162,7 @@ mod test {
 
         // Chain orphan 8 back to slot 4 on a different fork, ancestor search
         // should not return ancestors earlier than the root
-        blockstore.add_tree(tr(4) / (tr(8)), true, true);
+        blockstore.add_tree(tr(4) / (tr(8)), true, true, 2, Hash::default());
         assert_eq!(
             repair_weight.find_ancestor_subtree_of_slot(&blockstore, 8),
             (vec![4].into_iter().collect::<VecDeque<_>>(), None)
@@ -1242,8 +1249,8 @@ mod test {
         */
 
         let blockstore = setup_forks();
-        blockstore.add_tree(tr(8) / (tr(10) / (tr(11))), true, true);
-        blockstore.add_tree(tr(20) / (tr(22) / (tr(23))), true, true);
+        blockstore.add_tree(tr(8) / (tr(10) / (tr(11))), true, true, 2, Hash::default());
+        blockstore.add_tree(tr(20) / (tr(22) / (tr(23))), true, true, 2, Hash::default());
         assert!(blockstore.orphan(8).unwrap().is_some());
         blockstore
     }
@@ -1265,7 +1272,7 @@ mod test {
         let forks = tr(0) / (tr(1) / (tr(2) / (tr(4))) / (tr(3) / (tr(5) / (tr(6)))));
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Blockstore::open(&ledger_path).unwrap();
-        blockstore.add_tree(forks, false, true);
+        blockstore.add_tree(forks, false, true, 2, Hash::default());
         blockstore
     }
 }
diff --git a/core/src/repair_weighted_traversal.rs b/core/src/repair_weighted_traversal.rs
index b1f1b96165..e0c94bd4f9 100644
--- a/core/src/repair_weighted_traversal.rs
+++ b/core/src/repair_weighted_traversal.rs
@@ -151,6 +151,7 @@ pub mod test {
     use super::*;
     use solana_ledger::{get_tmp_ledger_path, shred::Shred};
     use solana_runtime::bank_utils;
+    use solana_sdk::hash::Hash;
     use trees::tr;
 
     #[test]
@@ -247,7 +248,13 @@ pub mod test {
         repairs = vec![];
         let best_overall_slot = heaviest_subtree_fork_choice.best_overall_slot();
         assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 4);
-        blockstore.add_tree(tr(best_overall_slot) / (tr(6) / tr(7)), true, false);
+        blockstore.add_tree(
+            tr(best_overall_slot) / (tr(6) / tr(7)),
+            true,
+            false,
+            2,
+            Hash::default(),
+        );
         get_best_repair_shreds(
             &heaviest_subtree_fork_choice,
             &blockstore,
@@ -301,7 +308,7 @@ pub mod test {
         // Adding incomplete children with higher weighted parents, even if
         // the parents are complete should still be repaired
         repairs = vec![];
-        blockstore.add_tree(tr(2) / (tr(8)), true, false);
+        blockstore.add_tree(tr(2) / (tr(8)), true, false, 2, Hash::default());
         get_best_repair_shreds(
             &heaviest_subtree_fork_choice,
             &blockstore,
@@ -323,7 +330,7 @@ pub mod test {
         let (blockstore, heaviest_subtree_fork_choice) = setup_forks();
         // Add a branch to slot 2, make sure it doesn't repair child
         // 4 again when the Unvisited(2) event happens
-        blockstore.add_tree(tr(2) / (tr(6) / tr(7)), true, false);
+        blockstore.add_tree(tr(2) / (tr(6) / tr(7)), true, false, 2, Hash::default());
         let mut repairs = vec![];
         get_best_repair_shreds(
             &heaviest_subtree_fork_choice,
@@ -369,7 +376,7 @@ pub mod test {
         // Adding slot 2 to ignore should not remove its unexplored children from
         // the repair set
         repairs = vec![];
-        blockstore.add_tree(tr(2) / (tr(6) / tr(7)), true, false);
+        blockstore.add_tree(tr(2) / (tr(6) / tr(7)), true, false, 2, Hash::default());
         ignore_set.insert(2);
         get_best_repair_shreds(
             &heaviest_subtree_fork_choice,
@@ -421,7 +428,7 @@ pub mod test {
         let forks = tr(0) / (tr(1) / (tr(2) / (tr(4))) / (tr(3) / (tr(5))));
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Blockstore::open(&ledger_path).unwrap();
-        blockstore.add_tree(forks.clone(), false, false);
+        blockstore.add_tree(forks.clone(), false, false, 2, Hash::default());
 
         (blockstore, HeaviestSubtreeForkChoice::new_from_tree(forks))
     }
diff --git a/core/src/replay_stage.rs b/core/src/replay_stage.rs
index 2edfa352e3..4d008a911c 100644
--- a/core/src/replay_stage.rs
+++ b/core/src/replay_stage.rs
@@ -1976,7 +1976,7 @@ pub(crate) mod tests {
             genesis_utils::create_genesis_config_with_vote_accounts(
                 10_000,
                 &validator_authorized_voter_keypairs,
-                100,
+                vec![100; validator_authorized_voter_keypairs.len()],
             );
 
         let bank0 = Bank::new(&genesis_config);
@@ -2702,15 +2702,9 @@ pub(crate) mod tests {
 
     #[test]
     fn test_compute_bank_stats_confirmed() {
-        let node_keypair = Keypair::new();
-        let vote_keypair = Keypair::new();
-        let stake_keypair = Keypair::new();
-        let node_pubkey = node_keypair.pubkey();
-        let mut keypairs = HashMap::new();
-        keypairs.insert(
-            node_pubkey,
-            ValidatorVoteKeypairs::new(node_keypair, vote_keypair, stake_keypair),
-        );
+        let vote_keypairs = ValidatorVoteKeypairs::new_rand();
+        let node_pubkey = vote_keypairs.node_keypair.pubkey();
+        let keypairs: HashMap<_, _> = vec![(node_pubkey, vote_keypairs)].into_iter().collect();
 
         let (bank_forks, mut progress, mut heaviest_subtree_fork_choice) =
             initialize_state(&keypairs, 10_000);
@@ -3029,14 +3023,8 @@ pub(crate) mod tests {
     #[test]
     fn test_update_slot_propagated_threshold_from_votes() {
         let keypairs: HashMap<_, _> = iter::repeat_with(|| {
-            let node_keypair = Keypair::new();
-            let vote_keypair = Keypair::new();
-            let stake_keypair = Keypair::new();
-            let node_pubkey = node_keypair.pubkey();
-            (
-                node_pubkey,
-                ValidatorVoteKeypairs::new(node_keypair, vote_keypair, stake_keypair),
-            )
+            let vote_keypairs = ValidatorVoteKeypairs::new_rand();
+            (vote_keypairs.node_keypair.pubkey(), vote_keypairs)
         })
         .take(10)
         .collect();
@@ -3209,17 +3197,10 @@ pub(crate) mod tests {
     #[test]
     fn test_update_propagation_status() {
         // Create genesis stakers
-        let node_keypair = Keypair::new();
-        let vote_keypair = Keypair::new();
-        let stake_keypair = Keypair::new();
-        let vote_pubkey = Arc::new(vote_keypair.pubkey());
-        let mut keypairs = HashMap::new();
-
-        keypairs.insert(
-            node_keypair.pubkey(),
-            ValidatorVoteKeypairs::new(node_keypair, vote_keypair, stake_keypair),
-        );
-
+        let vote_keypairs = ValidatorVoteKeypairs::new_rand();
+        let node_pubkey = vote_keypairs.node_keypair.pubkey();
+        let vote_pubkey = Arc::new(vote_keypairs.vote_keypair.pubkey());
+        let keypairs: HashMap<_, _> = vec![(node_pubkey, vote_keypairs)].into_iter().collect();
         let stake = 10_000;
         let (mut bank_forks, mut progress_map, _) = initialize_state(&keypairs, stake);
 
@@ -3301,14 +3282,8 @@ pub(crate) mod tests {
     #[test]
     fn test_chain_update_propagation_status() {
         let keypairs: HashMap<_, _> = iter::repeat_with(|| {
-            let node_keypair = Keypair::new();
-            let vote_keypair = Keypair::new();
-            let stake_keypair = Keypair::new();
-            let node_pubkey = node_keypair.pubkey();
-            (
-                node_pubkey,
-                ValidatorVoteKeypairs::new(node_keypair, vote_keypair, stake_keypair),
-            )
+            let vote_keypairs = ValidatorVoteKeypairs::new_rand();
+            (vote_keypairs.node_keypair.pubkey(), vote_keypairs)
         })
         .take(10)
         .collect();
@@ -3384,14 +3359,8 @@ pub(crate) mod tests {
     fn test_chain_update_propagation_status2() {
         let num_validators = 6;
         let keypairs: HashMap<_, _> = iter::repeat_with(|| {
-            let node_keypair = Keypair::new();
-            let vote_keypair = Keypair::new();
-            let stake_keypair = Keypair::new();
-            let node_pubkey = node_keypair.pubkey();
-            (
-                node_pubkey,
-                ValidatorVoteKeypairs::new(node_keypair, vote_keypair, stake_keypair),
-            )
+            let vote_keypairs = ValidatorVoteKeypairs::new_rand();
+            (vote_keypairs.node_keypair.pubkey(), vote_keypairs)
         })
         .take(num_validators)
         .collect();
diff --git a/core/src/rpc_pubsub.rs b/core/src/rpc_pubsub.rs
index d3685d1513..010351affc 100644
--- a/core/src/rpc_pubsub.rs
+++ b/core/src/rpc_pubsub.rs
@@ -986,11 +986,13 @@ mod tests {
             BlockCommitmentCache::new_for_tests_with_blockstore(blockstore.clone()),
         ));
 
-        let validator_voting_keypairs: Vec<_> = (0..10)
-            .map(|_| ValidatorVoteKeypairs::new(Keypair::new(), Keypair::new(), Keypair::new()))
-            .collect();
-        let GenesisConfigInfo { genesis_config, .. } =
-            create_genesis_config_with_vote_accounts(10_000, &validator_voting_keypairs, 100);
+        let validator_voting_keypairs: Vec<_> =
+            (0..10).map(|_| ValidatorVoteKeypairs::new_rand()).collect();
+        let GenesisConfigInfo { genesis_config, .. } = create_genesis_config_with_vote_accounts(
+            10_000,
+            &validator_voting_keypairs,
+            vec![100; validator_voting_keypairs.len()],
+        );
         let exit = Arc::new(AtomicBool::new(false));
         let bank = Bank::new(&genesis_config);
         let bank_forks = BankForks::new(bank);
diff --git a/core/src/validator.rs b/core/src/validator.rs
index 015c15461c..ecd292fcc4 100644
--- a/core/src/validator.rs
+++ b/core/src/validator.rs
@@ -849,6 +849,8 @@ impl TestValidator {
         } = create_genesis_config_with_leader_ex(
             mint_lamports,
             &contact_info.id,
+            &Keypair::new(),
+            &Pubkey::new_rand(),
             42,
             bootstrap_validator_lamports,
         );
@@ -865,17 +867,17 @@ impl TestValidator {
 
         let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
 
-        let leader_voting_keypair = Arc::new(voting_keypair);
         let config = ValidatorConfig {
             rpc_ports: Some((node.info.rpc.port(), node.info.rpc_pubsub.port())),
             ..ValidatorConfig::default()
         };
+        let vote_pubkey = voting_keypair.pubkey();
         let node = Validator::new(
             node,
             &node_keypair,
             &ledger_path,
-            &leader_voting_keypair.pubkey(),
-            vec![leader_voting_keypair.clone()],
+            &voting_keypair.pubkey(),
+            vec![Arc::new(voting_keypair)],
             None,
             true,
             &config,
@@ -887,7 +889,7 @@ impl TestValidator {
             alice: mint_keypair,
             ledger_path,
             genesis_hash: blockhash,
-            vote_pubkey: leader_voting_keypair.pubkey(),
+            vote_pubkey,
         }
     }
 }
diff --git a/core/tests/gossip.rs b/core/tests/gossip.rs
index 0985d4dbad..0f3783d501 100644
--- a/core/tests/gossip.rs
+++ b/core/tests/gossip.rs
@@ -29,13 +29,12 @@ fn test_node(exit: &Arc<AtomicBool>) -> (Arc<ClusterInfo>, GossipService, UdpSoc
 }
 
 fn test_node_with_bank(
-    node_keypair: Keypair,
+    node_keypair: Arc<Keypair>,
     exit: &Arc<AtomicBool>,
     bank_forks: Arc<RwLock<BankForks>>,
 ) -> (Arc<ClusterInfo>, GossipService, UdpSocket) {
-    let keypair = Arc::new(node_keypair);
-    let mut test_node = Node::new_localhost_with_pubkey(&keypair.pubkey());
-    let cluster_info = Arc::new(ClusterInfo::new(test_node.info.clone(), keypair));
+    let mut test_node = Node::new_localhost_with_pubkey(&node_keypair.pubkey());
+    let cluster_info = Arc::new(ClusterInfo::new(test_node.info.clone(), node_keypair));
     let gossip_service = GossipService::new(
         &cluster_info,
         Some(bank_forks),
@@ -224,13 +223,19 @@ pub fn cluster_info_scale() {
     let vote_keypairs: Vec<_> = (0..num_nodes)
         .map(|_| ValidatorVoteKeypairs::new_rand())
         .collect();
-    let genesis_config_info = create_genesis_config_with_vote_accounts(10_000, &vote_keypairs, 100);
+    let genesis_config_info = create_genesis_config_with_vote_accounts(
+        10_000,
+        &vote_keypairs,
+        vec![100; vote_keypairs.len()],
+    );
     let bank0 = Bank::new(&genesis_config_info.genesis_config);
     let bank_forks = Arc::new(RwLock::new(BankForks::new(bank0)));
 
     let nodes: Vec<_> = vote_keypairs
         .into_iter()
-        .map(|keypairs| test_node_with_bank(keypairs.node_keypair, &exit, bank_forks.clone()))
+        .map(|keypairs| {
+            test_node_with_bank(Arc::new(keypairs.node_keypair), &exit, bank_forks.clone())
+        })
         .collect();
     let ci0 = nodes[0].0.my_contact_info();
     for node in &nodes[1..] {
diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs
index 4265418ca2..b5a1e9b64d 100644
--- a/ledger/src/blockstore.rs
+++ b/ledger/src/blockstore.rs
@@ -350,18 +350,39 @@ impl Blockstore {
         Ok((blockstore, signal_receiver, completed_slots_receiver))
     }
 
-    pub fn add_tree(&self, forks: Tree<Slot>, is_orphan: bool, is_slot_complete: bool) {
+    pub fn add_tree(
+        &self,
+        forks: Tree<Slot>,
+        is_orphan: bool,
+        is_slot_complete: bool,
+        num_ticks: u64,
+        starting_hash: Hash,
+    ) {
         let mut walk = TreeWalk::from(forks);
+        let mut blockhashes = HashMap::new();
         while let Some(visit) = walk.get() {
             let slot = visit.node().data;
             if self.meta(slot).unwrap().is_some() && self.orphan(slot).unwrap().is_none() {
-                // If slot exists and is not an orphan, then skip it
+                // If slot exists in blockstore and is not an orphan, then skip it
                 walk.forward();
                 continue;
             }
             let parent = walk.get_parent().map(|n| n.data);
             if parent.is_some() || !is_orphan {
-                let entries = create_ticks(2, 0, Hash::default());
+                let parent_hash = parent
+                    // parent won't exist for first node in a tree where
+                    // `is_orphan == true`
+                    .and_then(|parent| blockhashes.get(&parent))
+                    .unwrap_or(&starting_hash);
+                let mut entries = create_ticks(
+                    num_ticks * (std::cmp::max(1, slot - parent.unwrap_or(slot))),
+                    0,
+                    *parent_hash,
+                );
+                blockhashes.insert(slot, entries.last().unwrap().hash);
+                if !is_slot_complete {
+                    entries.pop().unwrap();
+                }
                 let shreds = entries_to_test_shreds(
                     entries.clone(),
                     slot,
@@ -407,6 +428,16 @@ impl Blockstore {
         self.orphans_cf.get(slot)
     }
 
+    // Get max root or 0 if it doesn't exist
+    pub fn max_root(&self) -> Slot {
+        self.db
+            .iter::<cf::Root>(IteratorMode::End)
+            .expect("Couldn't get rooted iterator for max_root()")
+            .next()
+            .map(|(slot, _)| slot)
+            .unwrap_or(0)
+    }
+
     pub fn slot_meta_iterator<'a>(
         &'a self,
         slot: Slot,
diff --git a/local-cluster/src/cluster_tests.rs b/local-cluster/src/cluster_tests.rs
index b385c9b36e..8d083a5cc9 100644
--- a/local-cluster/src/cluster_tests.rs
+++ b/local-cluster/src/cluster_tests.rs
@@ -16,11 +16,10 @@ use solana_ledger::{
 use solana_sdk::{
     client::SyncClient,
     clock::{
-        self, Slot, DEFAULT_MS_PER_SLOT, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT,
-        NUM_CONSECUTIVE_LEADER_SLOTS,
+        self, Slot, DEFAULT_TICKS_PER_SECOND, DEFAULT_TICKS_PER_SLOT, NUM_CONSECUTIVE_LEADER_SLOTS,
     },
     commitment_config::CommitmentConfig,
-    epoch_schedule::{EpochSchedule, MINIMUM_SLOTS_PER_EPOCH},
+    epoch_schedule::MINIMUM_SLOTS_PER_EPOCH,
     hash::Hash,
     poh_config::PohConfig,
     pubkey::Pubkey,
@@ -172,11 +171,6 @@ pub fn verify_ledger_ticks(ledger_path: &Path, ticks_per_slot: usize) {
     }
 }
 
-pub fn time_until_nth_epoch(epoch: u64, slots_per_epoch: u64, stakers_slot_offset: u64) -> u64 {
-    let epoch_schedule = EpochSchedule::custom(slots_per_epoch, stakers_slot_offset, true);
-    epoch_schedule.get_last_slot_in_epoch(epoch) * DEFAULT_MS_PER_SLOT
-}
-
 pub fn sleep_n_epochs(
     num_epochs: f64,
     config: &PohConfig,
diff --git a/runtime/src/bank_utils.rs b/runtime/src/bank_utils.rs
index 312862dbe4..15c766a523 100644
--- a/runtime/src/bank_utils.rs
+++ b/runtime/src/bank_utils.rs
@@ -2,15 +2,12 @@ use crate::{
     bank::Bank,
     genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
 };
-use solana_sdk::{
-    pubkey::Pubkey,
-    signature::{Keypair, Signer},
-};
+use solana_sdk::{pubkey::Pubkey, signature::Signer};
 
 pub fn setup_bank_and_vote_pubkeys(num_vote_accounts: usize, stake: u64) -> (Bank, Vec<Pubkey>) {
     // Create some voters at genesis
     let validator_voting_keypairs: Vec<_> = (0..num_vote_accounts)
-        .map(|_| ValidatorVoteKeypairs::new(Keypair::new(), Keypair::new(), Keypair::new()))
+        .map(|_| ValidatorVoteKeypairs::new_rand())
         .collect();
 
     let vote_pubkeys: Vec<_> = validator_voting_keypairs
@@ -21,7 +18,7 @@ pub fn setup_bank_and_vote_pubkeys(num_vote_accounts: usize, stake: u64) -> (Ban
         genesis_utils::create_genesis_config_with_vote_accounts(
             10_000,
             &validator_voting_keypairs,
-            stake,
+            vec![stake; validator_voting_keypairs.len()],
         );
     let bank = Bank::new(&genesis_config);
     (bank, vote_pubkeys)
diff --git a/runtime/src/genesis_utils.rs b/runtime/src/genesis_utils.rs
index 000a9ead13..badb51feae 100644
--- a/runtime/src/genesis_utils.rs
+++ b/runtime/src/genesis_utils.rs
@@ -51,27 +51,40 @@ pub fn create_genesis_config(mint_lamports: u64) -> GenesisConfigInfo {
 pub fn create_genesis_config_with_vote_accounts(
     mint_lamports: u64,
     voting_keypairs: &[impl Borrow<ValidatorVoteKeypairs>],
-    stake: u64,
+    stakes: Vec<u64>,
 ) -> GenesisConfigInfo {
-    let mut genesis_config_info = create_genesis_config(mint_lamports);
-    for validator_voting_keypairs in voting_keypairs {
+    assert!(!voting_keypairs.is_empty());
+    assert_eq!(voting_keypairs.len(), stakes.len());
+
+    let mut genesis_config_info = create_genesis_config_with_leader_ex(
+        mint_lamports,
+        &voting_keypairs[0].borrow().node_keypair.pubkey(),
+        &voting_keypairs[0].borrow().vote_keypair,
+        &voting_keypairs[0].borrow().stake_keypair.pubkey(),
+        stakes[0],
+        BOOTSTRAP_VALIDATOR_LAMPORTS,
+    );
+
+    for (validator_voting_keypairs, stake) in voting_keypairs[1..].iter().zip(&stakes[1..]) {
         let node_pubkey = validator_voting_keypairs.borrow().node_keypair.pubkey();
         let vote_pubkey = validator_voting_keypairs.borrow().vote_keypair.pubkey();
         let stake_pubkey = validator_voting_keypairs.borrow().stake_keypair.pubkey();
 
         // Create accounts
-        let vote_account = vote_state::create_account(&vote_pubkey, &node_pubkey, 0, stake);
+        let node_account = Account::new(BOOTSTRAP_VALIDATOR_LAMPORTS, 0, &system_program::id());
+        let vote_account = vote_state::create_account(&vote_pubkey, &node_pubkey, 0, *stake);
         let stake_account = stake_state::create_account(
             &stake_pubkey,
             &vote_pubkey,
             &vote_account,
             &genesis_config_info.genesis_config.rent,
-            stake,
+            *stake,
         );
 
         // Put newly created accounts into genesis
         genesis_config_info.genesis_config.accounts.extend(vec![
-            (vote_pubkey, vote_account.clone()),
+            (node_pubkey, node_account),
+            (vote_pubkey, vote_account),
             (stake_pubkey, stake_account),
         ]);
     }
@@ -87,6 +100,8 @@ pub fn create_genesis_config_with_leader(
     create_genesis_config_with_leader_ex(
         mint_lamports,
         bootstrap_validator_pubkey,
+        &Keypair::new(),
+        &Pubkey::new_rand(),
         bootstrap_validator_stake_lamports,
         BOOTSTRAP_VALIDATOR_LAMPORTS,
     )
@@ -95,13 +110,12 @@ pub fn create_genesis_config_with_leader(
 pub fn create_genesis_config_with_leader_ex(
     mint_lamports: u64,
     bootstrap_validator_pubkey: &Pubkey,
+    bootstrap_validator_voting_keypair: &Keypair,
+    bootstrap_validator_staking_pubkey: &Pubkey,
     bootstrap_validator_stake_lamports: u64,
     bootstrap_validator_lamports: u64,
 ) -> GenesisConfigInfo {
     let mint_keypair = Keypair::new();
-    let bootstrap_validator_voting_keypair = Keypair::new();
-    let bootstrap_validator_staking_keypair = Keypair::new();
-
     let bootstrap_validator_vote_account = vote_state::create_account(
         &bootstrap_validator_voting_keypair.pubkey(),
         &bootstrap_validator_pubkey,
@@ -112,7 +126,7 @@ pub fn create_genesis_config_with_leader_ex(
     let rent = Rent::free();
 
     let bootstrap_validator_stake_account = stake_state::create_account(
-        &bootstrap_validator_staking_keypair.pubkey(),
+        bootstrap_validator_staking_pubkey,
         &bootstrap_validator_voting_keypair.pubkey(),
         &bootstrap_validator_vote_account,
         &rent,
@@ -133,7 +147,7 @@ pub fn create_genesis_config_with_leader_ex(
             bootstrap_validator_vote_account,
         ),
         (
-            bootstrap_validator_staking_keypair.pubkey(),
+            *bootstrap_validator_staking_pubkey,
             bootstrap_validator_stake_account,
         ),
     ]
@@ -154,6 +168,7 @@ pub fn create_genesis_config_with_leader_ex(
     GenesisConfigInfo {
         genesis_config,
         mint_keypair,
-        voting_keypair: bootstrap_validator_voting_keypair,
+        voting_keypair: Keypair::from_bytes(&bootstrap_validator_voting_keypair.to_bytes())
+            .unwrap(),
     }
 }