diff --git a/routing/pathfind.go b/routing/pathfind.go
index 923ce9c2..080d46c9 100644
--- a/routing/pathfind.go
+++ b/routing/pathfind.go
@@ -159,41 +159,6 @@ func (r *Route) ToHopPayloads() []sphinx.HopData {
 	return hopPayloads
 }
 
-// sortableRoutes is a slice of routes that can be sorted. Routes are typically
-// sorted according to their total cumulative fee within the route. In the case
-// that two routes require and identical amount of fees, then the total
-// time-lock will be used as the tie breaker.
-type sortableRoutes []*Route
-
-// Len returns the number of routes in the collection.
-//
-// NOTE: This is part of the sort.Interface implementation.
-func (s sortableRoutes) Len() int {
-	return len(s)
-}
-
-// Less reports whether the route with index i should sort before the route
-// with index j. To make this decision we first check if the total fees
-// required for both routes are equal. If so, then we'll let the total time
-// lock be the tie breaker. Otherwise, we'll put the route with the lowest
-// total fees first.
-//
-// NOTE: This is part of the sort.Interface implementation.
-func (s sortableRoutes) Less(i, j int) bool {
-	if s[i].TotalFees == s[j].TotalFees {
-		return s[i].TotalTimeLock < s[j].TotalTimeLock
-	}
-
-	return s[i].TotalFees < s[j].TotalFees
-}
-
-// Swap swaps the elements with indexes i and j.
-//
-// NOTE: This is part of the sort.Interface implementation.
-func (s sortableRoutes) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
-
 // newRoute returns a fully valid route between the source and target that's
 // capable of supporting a payment of `amtToSend` after fees are fully
 // computed. If the route is too long, or the selected path cannot support the
diff --git a/routing/router.go b/routing/router.go
index d9d1789f..e6da3d0f 100644
--- a/routing/router.go
+++ b/routing/router.go
@@ -869,7 +869,7 @@ func (r *ChannelRouter) FindRoutes(target *btcec.PublicKey,
 	// each path. During this process, some paths may be discarded if they
 	// aren't able to support the total satoshis flow once fees have been
 	// factored in.
-	validRoutes := make(sortableRoutes, 0, len(shortestPaths))
+	validRoutes := make([]*Route, 0, len(shortestPaths))
 	for _, path := range shortestPaths {
 		// Attempt to make the path into a route. We snip off the first
 		// hop in the path as it contains a "self-hop" that is inserted
@@ -894,7 +894,19 @@ func (r *ChannelRouter) FindRoutes(target *btcec.PublicKey,
 	// Finally, we'll sort the set of validate routes to optimize for
 	// lowest total fees, using the required time-lock within the route as
 	// a tie-breaker.
-	sort.Sort(validRoutes)
+	sort.Slice(validRoutes, func(i, j int) bool {
+		// To make this decision we first check if the total fees
+		// required for both routes are equal. If so, then we'll let the total time
+		// lock be the tie breaker. Otherwise, we'll put the route with the lowest
+		// total fees first.
+		if validRoutes[i].TotalFees == validRoutes[j].TotalFees {
+			timeLockI := validRoutes[i].TotalTimeLock
+			timeLockJ := validRoutes[j].TotalTimeLock
+			return timeLockI < timeLockJ
+		}
+
+		return validRoutes[i].TotalFees < validRoutes[j].TotalFees
+	})
 
 	log.Debugf("Obtained %v paths sending %v to %x: %v", len(validRoutes),
 		amt, dest, newLogClosure(func() string {