diff --git a/lnd_test.go b/lnd_test.go
index 660d6a687..dae99f566 100644
--- a/lnd_test.go
+++ b/lnd_test.go
@@ -220,25 +220,23 @@ func closeChannelAndAssert(ctx context.Context, t *harnessTest,
 	}
 	chanPointStr := fmt.Sprintf("%v:%v", txid, fundingChanPoint.OutputIndex)
 
-	// If we didn't force close the transaction, at this point, the channel
-	// should now be marked as being in the state of "waiting close".
-	if !force {
-		pendingChansRequest := &lnrpc.PendingChannelsRequest{}
-		pendingChanResp, err := node.PendingChannels(ctx, pendingChansRequest)
-		if err != nil {
-			t.Fatalf("unable to query for pending channels: %v", err)
-		}
-		var found bool
-		for _, pendingClose := range pendingChanResp.WaitingCloseChannels {
-			if pendingClose.Channel.ChannelPoint == chanPointStr {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Fatalf("channel not marked as waiting close")
+	// At this point, the channel should now be marked as being in the
+	// state of "waiting close".
+	pendingChansRequest := &lnrpc.PendingChannelsRequest{}
+	pendingChanResp, err := node.PendingChannels(ctx, pendingChansRequest)
+	if err != nil {
+		t.Fatalf("unable to query for pending channels: %v", err)
+	}
+	var found bool
+	for _, pendingClose := range pendingChanResp.WaitingCloseChannels {
+		if pendingClose.Channel.ChannelPoint == chanPointStr {
+			found = true
+			break
 		}
 	}
+	if !found {
+		t.Fatalf("channel not marked as waiting close")
+	}
 
 	// We'll now, generate a single block, wait for the final close status
 	// update, then ensure that the closing transaction was included in the
@@ -254,28 +252,26 @@ func closeChannelAndAssert(ctx context.Context, t *harnessTest,
 
 	// Finally, the transaction should no longer be in the waiting close
 	// state as we've just mined a block that should include the closing
-	// transaction. This only applies for co-op close channels though.
-	if !force {
-		err = lntest.WaitPredicate(func() bool {
-			pendingChansRequest := &lnrpc.PendingChannelsRequest{}
-			pendingChanResp, err := node.PendingChannels(
-				ctx, pendingChansRequest,
-			)
-			if err != nil {
+	// transaction.
+	err = lntest.WaitPredicate(func() bool {
+		pendingChansRequest := &lnrpc.PendingChannelsRequest{}
+		pendingChanResp, err := node.PendingChannels(
+			ctx, pendingChansRequest,
+		)
+		if err != nil {
+			return false
+		}
+
+		for _, pendingClose := range pendingChanResp.WaitingCloseChannels {
+			if pendingClose.Channel.ChannelPoint == chanPointStr {
 				return false
 			}
-
-			for _, pendingClose := range pendingChanResp.WaitingCloseChannels {
-				if pendingClose.Channel.ChannelPoint == chanPointStr {
-					return false
-				}
-			}
-
-			return true
-		}, time.Second*15)
-		if err != nil {
-			t.Fatalf("closing transaction not marked as fully closed")
 		}
+
+		return true
+	}, time.Second*15)
+	if err != nil {
+		t.Fatalf("closing transaction not marked as fully closed")
 	}
 
 	return closingTxid
@@ -8130,21 +8126,17 @@ func testMultiHopRemoteForceCloseOnChainHtlcTimeout(net *lntest.NetworkHarness,
 		t.Fatalf(predErr.Error())
 	}
 
-	// We'll mine csvDelay blocks in order to generate the sweep transaction
-	// of Bob's funding output.
-	if _, err := net.Miner.Node.Generate(csvDelay - 1); err != nil {
-		t.Fatalf("unable to generate blocks: %v", err)
-	}
-
-	_, err = waitForTxInMempool(net.Miner.Node, 10*time.Second)
+	// Bob can sweep his output immediately.
+	_, err = waitForTxInMempool(net.Miner.Node, 20*time.Second)
 	if err != nil {
-		t.Fatalf("unable to find bob's funding output sweep tx: %v", err)
+		t.Fatalf("unable to find bob's funding output sweep tx: %v",
+			err)
 	}
 
 	// Next, we'll mine enough blocks for the HTLC to expire. At this
 	// point, Bob should hand off the output to his internal utxo nursery,
 	// which will broadcast a sweep transaction.
-	if _, err := net.Miner.Node.Generate(finalCltvDelta - csvDelay - 1); err != nil {
+	if _, err := net.Miner.Node.Generate(finalCltvDelta - 1); err != nil {
 		t.Fatalf("unable to generate blocks: %v", err)
 	}