diff --git a/pageserver/benches/bench_layer_map.rs b/pageserver/benches/bench_layer_map.rs
index b35395b3c8..b8fe06785e 100644
--- a/pageserver/benches/bench_layer_map.rs
+++ b/pageserver/benches/bench_layer_map.rs
@@ -180,6 +180,7 @@ fn build_layer_map(filename_dump: PathBuf) -> LayerMap {
             panic!("unexpected filename {fname}");
         }
     }
+    layer_map.rebuild_index();
 
     println!("min: {min_lsn}, max: {max_lsn}");
 
@@ -256,15 +257,15 @@ fn bench_from_real_project(c: &mut Criterion) {
     let mut bstlm = PersistentLayerMap::new();
     let mut sorted_layers: Vec<_> = layer_map.iter_historic_layers().collect();
     sorted_layers.sort_by(|a, b| a.get_lsn_range().start.cmp(&b.get_lsn_range().start));
+
     // TODO implement out of order inserts
     for layer in sorted_layers {
         let kr = layer.get_key_range();
         let lr = layer.get_lsn_range();
 
         bstlm.insert(
-            kr.start.to_i128(),
-            kr.end.to_i128(),
-            lr.start.0,
+            kr.start.to_i128()..kr.end.to_i128(),
+            lr.start.0..lr.end.0,
             format!("Layer {}", lr.start.0),
         );
     }
@@ -311,6 +312,7 @@ fn bench_sequential(c: &mut Criterion) {
         };
         layer_map.insert_historic(Arc::new(layer));
     }
+    layer_map.rebuild_index();
     println!("Finished layer map init in {:?}", now.elapsed());
 
     // Init bst layer map with the same layers
@@ -324,9 +326,8 @@ fn bench_sequential(c: &mut Criterion) {
         let lr = layer.get_lsn_range();
 
         bstlm.insert(
-            kr.start.to_i128(),
-            kr.end.to_i128(),
-            lr.start.0,
+            kr.start.to_i128()..kr.end.to_i128(),
+            lr.start.0..lr.end.0,
             format!("Layer {}", lr.start.0),
         );
     }
diff --git a/pageserver/src/tenant/bst_layer_map.rs b/pageserver/src/tenant/bst_layer_map.rs
index d4dee3e60d..7c9eaff337 100644
--- a/pageserver/src/tenant/bst_layer_map.rs
+++ b/pageserver/src/tenant/bst_layer_map.rs
@@ -255,6 +255,12 @@ impl<Value: std::fmt::Debug> std::fmt::Debug for RetroactiveLayerMap<Value> {
     }
 }
 
+impl<T: Clone> Default for RetroactiveLayerMap<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<Value: Clone> RetroactiveLayerMap<Value> {
     pub fn new() -> Self {
         Self {
diff --git a/pageserver/src/tenant/layer_map.rs b/pageserver/src/tenant/layer_map.rs
index 36bc6c550d..2e40312293 100644
--- a/pageserver/src/tenant/layer_map.rs
+++ b/pageserver/src/tenant/layer_map.rs
@@ -28,7 +28,7 @@ use std::sync::Arc;
 use tracing::*;
 use utils::lsn::Lsn;
 
-use super::bst_layer_map::PersistentLayerMap;
+use super::bst_layer_map::RetroactiveLayerMap;
 
 ///
 /// LayerMap tracks what layers exist on a timeline.
@@ -59,7 +59,7 @@ pub struct LayerMap {
 
     /// HACK I'm experimenting with a new index to reaplace the RTree. If this
     ///      works out I'll clean up the struct later.
-    index: PersistentLayerMap<Arc<dyn Layer>>,
+    index: RetroactiveLayerMap<Arc<dyn Layer>>,
 
     /// L0 layers have key range Key::MIN..Key::MAX, and locating them using R-Tree search is very inefficient.
     /// So L0 layers are held in l0_delta_layers vector, in addition to the R-tree.
@@ -374,11 +374,16 @@ impl LayerMap {
         if layer.get_key_range() == (Key::MIN..Key::MAX) {
             self.l0_delta_layers.push(layer.clone());
         }
-        // HACK don't update RTree, too slow
-        // self.historic_layers.insert(LayerRTreeObject::new(layer));
+        // TODO remove this so insert isn't slow. I need it for now for iter_historic()
+        self.historic_layers.insert(LayerRTreeObject::new(layer));
         NUM_ONDISK_LAYERS.inc();
     }
 
+    /// Must be called after a batch of insert_historic calls, before querying
+    pub fn rebuild_index(&mut self) {
+        self.index.rebuild();
+    }
+
     ///
     /// Remove an on-disk layer from the map.
     ///