diff --git a/pageserver/src/keyspace.rs b/pageserver/src/keyspace.rs
index bbaa127e4c..64024a2d8d 100644
--- a/pageserver/src/keyspace.rs
+++ b/pageserver/src/keyspace.rs
@@ -10,7 +10,6 @@ pub struct KeySpace {
     /// Contiguous ranges of keys that belong to the key space. In key order,
     /// and with no overlap.
     pub ranges: Vec<Range<Key>>,
-    pub start: Key,
 }
 
 impl KeySpace {
@@ -23,20 +22,16 @@ impl KeySpace {
         let target_nblocks = (target_size / BLCKSZ as u64) as usize;
 
         let mut parts = Vec::new();
-        let mut current_part: Vec<Range<Key>> = Vec::new();
+        let mut current_part = Vec::new();
         let mut current_part_size: usize = 0;
-        let mut part_start = Key::MIN;
         for range in &self.ranges {
             // If appending the next contiguous range in the keyspace to the current
             // partition would cause it to be too large, start a new partition.
             let this_size = key_range_size(range) as usize;
             if current_part_size + this_size > target_nblocks && !current_part.is_empty() {
-                let part_end = current_part.last().unwrap().end;
                 parts.push(KeySpace {
                     ranges: current_part,
-                    start: part_start,
                 });
-                part_start = part_end;
                 current_part = Vec::new();
                 current_part_size = 0;
             }
@@ -49,10 +44,8 @@ impl KeySpace {
                 let next = start.add(target_nblocks as u32);
                 parts.push(KeySpace {
                     ranges: vec![start..next],
-                    start: part_start,
                 });
                 start = next;
-                part_start = next;
                 remain_size -= target_nblocks
             }
             current_part.push(start..range.end);
@@ -63,7 +56,6 @@ impl KeySpace {
         if !current_part.is_empty() {
             parts.push(KeySpace {
                 ranges: current_part,
-                start: part_start,
             });
         }
 
@@ -134,7 +126,6 @@ impl KeySpaceAccum {
         }
         KeySpace {
             ranges: self.ranges,
-            start: Key::MIN,
         }
     }
 }
diff --git a/pageserver/src/tenant/timeline.rs b/pageserver/src/tenant/timeline.rs
index 5dbcf17e7a..440b8204db 100644
--- a/pageserver/src/tenant/timeline.rs
+++ b/pageserver/src/tenant/timeline.rs
@@ -2914,18 +2914,7 @@ impl Timeline {
 
         let mut max_deltas = 0;
         let wanted_image_layers = self.wanted_image_layers.lock().unwrap();
-        if let Some(wanted) = &*wanted_image_layers {
-            let img_range = partition.start..partition.ranges.last().unwrap().end;
-            if let Some((_start, end)) = wanted.range(..img_range.end).next_back() {
-                if *end > img_range.start {
-                    info!(
-                        "Force generation of layer {}-{} wanted by GC)",
-                        img_range.start, img_range.end
-                    );
-                    return Ok(true);
-                }
-            }
-        }
+
         for part_range in &partition.ranges {
             let image_coverage = layers.image_coverage(part_range, lsn)?;
             for (img_range, last_img) in image_coverage {
@@ -2958,6 +2947,26 @@ impl Timeline {
                         );
                         return Ok(true);
                     }
+                    if num_deltas > 0 {
+                        if let Some(wanted) = &*wanted_image_layers {
+                            if let Some((_start, end)) = wanted.range(..img_range.end).next_back() {
+                                if *end > img_range.start {
+                                    info!(
+                                        "Force generation of layer {}-{} wanted by GC ({} deltas)",
+                                        img_range.start, img_range.end, num_deltas
+                                    );
+                                    return Ok(true);
+                                } else {
+                                    info!(
+                                        "Image {}-{} is not wanted",
+                                        img_range.start, img_range.end
+                                    );
+                                }
+                            }
+                        }
+                    } else {
+                        info!("No deltas for range  {}-{}", img_range.start, img_range.end);
+                    }
                 }
             }
         }
@@ -2994,7 +3003,8 @@ impl Timeline {
             let img_range = start..partition.ranges.last().unwrap().end;
             start = img_range.end;
             if force || self.time_for_new_image_layer(partition, lsn)? {
-                let img_range = partition.start..partition.ranges.last().unwrap().end;
+                let img_range =
+                    partition.ranges.first().unwrap().start..partition.ranges.last().unwrap().end;
                 let mut image_layer_writer = ImageLayerWriter::new(
                     self.conf,
                     self.timeline_id,
@@ -3861,17 +3871,23 @@ impl Timeline {
                                         end = *prev_end;
                                     }
                                 }
-                            } else {
                                 break;
+                            } else {
+                                to_remove.push(*prev_start);
+                                if *prev_end > end {
+                                    end = *prev_end;
+                                }
                             }
+                        } else {
+                            break;
                         }
-                        for key in to_remove {
-                            wanted_image_layers.remove(&key);
-                        }
-                        if insert_new_range {
-                            info!("Wanted image {}..{}", start, end);
-                            wanted_image_layers.insert(start, end);
-                        }
+                    }
+                    for key in to_remove {
+                        wanted_image_layers.remove(&key);
+                    }
+                    if insert_new_range {
+                        info!("Wanted image {}..{}", start, end);
+                        wanted_image_layers.insert(start, end);
                     }
                 }
                 result.layers_not_updated += 1;