diff --git a/src/whisker/route.rs b/src/whisker/route.rs
index 89810915547c87677e813003126d5d9c87187278..33ef8c29aa360a69a352bfd4d18820ee5a5a73e1 100644
--- a/src/whisker/route.rs
+++ b/src/whisker/route.rs
@@ -66,10 +66,6 @@ impl Route {
     /// Returns an Err if the route is out of space, or appending the node doesn't make logical sense
     /// (there's a future node that doesn't match)
     pub fn append_node(&mut self, callsign: &str, ssid: u8) -> Result<(), AppendNodeError> {
-        if usize::from(self.max_hops) == self.iter().count() {
-            return Err(AppendNodeError::HopsOverflow);
-        }
-
         let mut new_route = Route::new(self.max_hops);
 
         let mut already_inserted = false;
@@ -111,41 +107,12 @@ impl Route {
             new_route.push_callsign(callsign, ssid, false);
         }
 
-        *self = new_route;
-        Ok(())
-        /*
-        let replace_future = r.iter().any(|rn| match rn {
-            RouteNode::Identity(rc, rs, is_future) => rc == callsign && rs == ssid && is_future,
-            _ => false,
-        });
-
-        if replace_future {
-            let mut new_route = Route::new(r.max_hops);
-            let mut already_replaced = false;
-
-            for rn in r.iter() {
-                match rn {
-                    RouteNode::Identity(rc, rs, is_future)
-                        if rc == callsign && rs == ssid && is_future && !already_replaced =>
-                    {
-                        already_replaced = true;
-                        new_route.push_callsign(callsign, ssid, false)?;
-                    }
-                    RouteNode::Identity(rc, rs, is_future) => {
-                        new_route.push_callsign(rc, rs, is_future)?;
-                    }
-                    RouteNode::Internet => {
-                        new_route.push_internet()?;
-                    }
-                }
-            }
-
-            *r = new_route;
-        } else {
-            r.push_callsign(callsign, ssid, false)?;
+        if new_route.iter().count() > usize::from(new_route.max_hops) {
+            return Err(AppendNodeError::HopsOverflow);
         }
 
-        Some(())*/
+        *self = new_route;
+        Ok(())
     }
 
     pub fn iter(&'_ self) -> RouteIter<'_> {
@@ -347,6 +314,24 @@ mod tests {
         assert_eq!(None, iter.next());
     }
 
+    #[test]
+    fn append_overwrites_future_even_when_at_hop_limit() {
+        let mut r = Route::new(4);
+        r.push_callsign("C1", 0, false);
+        r.push_callsign("C2", 0, false);
+        r.push_callsign("C3", 0, true);
+        r.push_callsign("C4", 0, true);
+
+        r.append_node("C3", 0).unwrap();
+
+        let mut iter = r.iter();
+        assert_eq!(Some(RouteNode::Identity("C1", 0, false)), iter.next());
+        assert_eq!(Some(RouteNode::Identity("C2", 0, false)), iter.next());
+        assert_eq!(Some(RouteNode::Identity("C3", 0, false)), iter.next());
+        assert_eq!(Some(RouteNode::Identity("C4", 0, true)), iter.next());
+        assert_eq!(None, iter.next());
+    }
+
     #[test]
     fn append_appends_when_no_future() {
         let mut r = Route::new(5);