diff --git a/protofsm/log.go b/protofsm/log.go
index ea1728ab8..8ff9c1b62 100644
--- a/protofsm/log.go
+++ b/protofsm/log.go
@@ -12,7 +12,7 @@ var log btclog.Logger
 
 // The default amount of logging is none.
 func init() {
-	UseLogger(build.NewSubLogger("PRCL", nil))
+	UseLogger(build.NewSubLogger("PFSM", nil))
 }
 
 // DisableLog disables all library log output.  Logging output is disabled
diff --git a/protofsm/state_machine.go b/protofsm/state_machine.go
index eb967f2a2..b583d4a8d 100644
--- a/protofsm/state_machine.go
+++ b/protofsm/state_machine.go
@@ -8,7 +8,6 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
-	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/lnutils"
@@ -28,7 +27,7 @@ type EmittedEvent[Event any] struct {
 	// InternalEvent is an optional internal event that is to be routed
 	// back to the target state. This enables state to trigger one or many
 	// state transitions without a new external event.
-	InternalEvent fn.Option[Event]
+	InternalEvent fn.Option[[]Event]
 
 	// ExternalEvent is an optional external event that is to be sent to
 	// the daemon for dispatch. Usually, this is some form of I/O.
@@ -329,7 +328,7 @@ func (s *StateMachine[Event, Env]) executeDaemonEvent( //nolint:funlen
 	// any preconditions as well as post-send events.
 	case *SendMsgEvent[Event]:
 		sendAndCleanUp := func() error {
-			log.Debugf("FSM(%v): sending message to target(%v): "+
+			log.Debugf("FSM(%v): sending message to target(%x): "+
 				"%v", s.cfg.Env.Name(),
 				daemonEvent.TargetPeer.SerializeCompressed(),
 				lnutils.SpewLogClosure(daemonEvent.Msgs),
@@ -451,7 +450,11 @@ func (s *StateMachine[Event, Env]) executeDaemonEvent( //nolint:funlen
 			defer s.wg.Done()
 			for {
 				select {
-				case spend := <-spendEvent.Spend:
+				case spend, ok := <-spendEvent.Spend:
+					if !ok {
+						return
+					}
+
 					// If there's a post-send event, then
 					// we'll send that into the current
 					// state now.
@@ -522,11 +525,8 @@ func (s *StateMachine[Event, Env]) applyEvents(currentState State[Event, Env],
 	newEvent Event) (State[Event, Env], error) {
 
 	log.Debugf("FSM(%v): applying new event", s.cfg.Env.Name(),
-		lnutils.NewLogClosure(func() string {
-			return spew.Sdump(newEvent)
-		}),
+		lnutils.SpewLogClosure(newEvent),
 	)
-
 	eventQueue := fn.NewQueue(newEvent)
 
 	// Given the next event to handle, we'll process the event, then add
@@ -539,9 +539,7 @@ func (s *StateMachine[Event, Env]) applyEvents(currentState State[Event, Env],
 		err := fn.MapOptionZ(nextEvent, func(event Event) error {
 			log.Debugf("FSM(%v): processing event: %v",
 				s.cfg.Env.Name(),
-				lnutils.NewLogClosure(func() string {
-					return spew.Sdump(event)
-				}),
+				lnutils.SpewLogClosure(event),
 			)
 
 			// Apply the state transition function of the current
@@ -584,19 +582,19 @@ func (s *StateMachine[Event, Env]) applyEvents(currentState State[Event, Env],
 				// our event queue.
 				//
 				//nolint:lll
-				events.InternalEvent.WhenSome(func(es Event) {
-					log.Debugf("FSM(%v): adding "+
-						"new internal event "+
-						"to queue: %v",
-						s.cfg.Env.Name(),
-						lnutils.NewLogClosure(func() string { //nolint:lll
-							return spew.Sdump( //nolint:lll
-								es,
-							)
-						}),
-					)
+				events.InternalEvent.WhenSome(func(es []Event) {
+					for _, inEvent := range es {
+						log.Debugf("FSM(%v): adding "+
+							"new internal event "+
+							"to queue: %v",
+							s.cfg.Env.Name(),
+							lnutils.SpewLogClosure(
+								inEvent,
+							),
+						)
 
-					eventQueue.Enqueue(es)
+						eventQueue.Enqueue(inEvent)
+					}
 				})
 
 				return nil
diff --git a/protofsm/state_machine_test.go b/protofsm/state_machine_test.go
index 0a09af60b..0432f386b 100644
--- a/protofsm/state_machine_test.go
+++ b/protofsm/state_machine_test.go
@@ -80,7 +80,9 @@ func (d *dummyStateStart) ProcessEvent(event dummyEvents, env *dummyEnv,
 		return &StateTransition[dummyEvents, *dummyEnv]{
 			NextState: &dummyStateStart{},
 			NewEvents: fn.Some(EmittedEvent[dummyEvents]{
-				InternalEvent: fn.Some(dummyEvents(&goToFin{})),
+				InternalEvent: fn.Some(
+					[]dummyEvents{&goToFin{}},
+				),
 			}),
 		}, nil