diff --git a/plugins/askrene/refine.c b/plugins/askrene/refine.c
index 2ee3855e2f..118460eb9d 100644
--- a/plugins/askrene/refine.c
+++ b/plugins/askrene/refine.c
@@ -588,36 +598,37 @@ double flows_probability(const tal_t *ctx, struct route_query *rq,
 	return probability;
 }
 
-/* Compare flows by remaining capacity (note: they are not reserved, so this
- * capacity includes current capacity. */
-static int reverse_cmp_capacity(struct flow *const *fa, struct flow *const *fb,
-				struct route_query *rq)
-{
-	struct amount_msat amount_a, amount_b;
-
-	amount_a = flow_max_deliverable(rq, *fa);
-	amount_b = flow_max_deliverable(rq, *fb);
-	if (!amount_msat_deduct(&amount_a, (*fa)->delivers))
-		abort();
-	if (!amount_msat_deduct(&amount_b, (*fb)->delivers))
-		abort();
-
-	if (amount_msat_eq(amount_a, amount_b))
-		return 0;
-	if (amount_msat_greater(amount_a, amount_b))
-		return -1;
-	return 1;
-}
-
 const char *reduce_num_flows(const tal_t *ctx,
 			     const struct route_query *rq,
 			     struct flow ***flows,
 			     struct amount_msat deliver,
 			     size_t num_parts)
 {
-	/* Keep the largest-capacity flows */
+	/* Keep the largest flows (not as I originally implemented, the largest
+	 * capacity flows).  Here's Lagrang3's analysis:
+	 *
+	 * I think it is better to keep the largest-deliver flows.  If we only
+	 * go for the highest capacity we may throw away the low cost benefits
+	 * of the MCF.
+
+	 * Hypothetical scenario: MCF finds 3 flows but maxparts=2,
+	 * flow 1: deliver=10, cost=0, capacity=0
+	 * flow 2: deliver=7, cost=1, capacity=5
+	 * flow 3: deliver=1, cost=10, capacity=100
+	 *
+	 * It is better to keep flows 1 and 2 by accomodating 1 more unit of
+	 * flow in flow2 at 1 value expense (per flow), than to keep flows 2 and
+	 * 3 by accomodating 5 more units of flow in flow2 at cost 1 and 5 in
+	 * flow3 at cost 100.
+	 *
+	 * The trade-off is: if we prioritize the delivery value already
+	 * computed by MCF then we find better solutions, but we might fail to
+	 * find feasible solutions sometimes. If we prioritize capacity then we
+	 * generally find bad solutions though we find feasibility more often
+	 * than the alternative.
+	 */
 	size_t orig_num_flows = tal_count(*flows);
-	asort(*flows, orig_num_flows, reverse_cmp_capacity, cast_const(struct route_query *, rq));
+	asort(*flows, orig_num_flows, revcmp_flows, NULL);
 	tal_resize(flows, num_parts);
 
 	if (!increase_flows(rq, *flows, deliver, -1.0))