diff --git a/daemon/cmd/hubble.go b/daemon/cmd/hubble.go
index 68da7f4bf8b5..4d8add612340 100644
--- a/daemon/cmd/hubble.go
+++ b/daemon/cmd/hubble.go
@@ -16,7 +16,6 @@ package cmd
 
 import (
 	"context"
-	"strings"
 	"time"
 
 	"github.com/cilium/cilium/api/v1/models"
@@ -127,11 +126,9 @@ func (d *Daemon) launchHubble() {
 	address := option.Config.HubbleListenAddress
 	if address != "" {
 		// TODO: remove warning once mutual TLS has been implemented
-		if !strings.HasPrefix(address, "unix://") {
-			logger.WithField("address", address).Warn("Hubble server will be exposing its API insecurely on this address")
-		}
+		logger.WithField("address", address).Warn("Hubble server will be exposing its API insecurely on this address")
 		srv, err := server.NewServer(logger,
-			serveroption.WithListeners([]string{address}),
+			serveroption.WithTCPListener(address),
 			serveroption.WithHealthService(),
 			serveroption.WithObserverService(d.hubbleObserver),
 		)
diff --git a/pkg/hubble/server/server.go b/pkg/hubble/server/server.go
index b0a2506082eb..921fe7dcccc5 100644
--- a/pkg/hubble/server/server.go
+++ b/pkg/hubble/server/server.go
@@ -38,9 +38,7 @@ type Server struct {
 
 // NewServer creates a new hubble gRPC server.
 func NewServer(log *logrus.Entry, options ...serveroption.Option) (*Server, error) {
-	opts := serveroption.Options{
-		Listeners: make(map[string]net.Listener),
-	}
+	opts := serveroption.Options{}
 	for _, opt := range options {
 		if err := opt(&opts); err != nil {
 			return nil, fmt.Errorf("failed to apply option: %v", err)
@@ -68,12 +66,16 @@ func (s *Server) initGRPCServer() {
 // listeners. Stop should be called to stop the server.
 func (s *Server) Serve() error {
 	s.initGRPCServer()
-	for name, listener := range s.opts.Listeners {
-		go func(name string, listener net.Listener) {
-			if err := s.srv.Serve(listener); err != nil {
-				s.log.WithError(err).Error("failed to close grpc server")
-			}
-		}(name, listener)
+	for _, listener := range []net.Listener{s.opts.UnixSocketListener, s.opts.TCPListener} {
+		if listener != nil {
+			go func(listener net.Listener) {
+				if err := s.srv.Serve(listener); err != nil {
+					s.log.WithError(err).
+						WithField("address", listener.Addr().String()).
+						Error("failed to start grpc server")
+				}
+			}(listener)
+		}
 	}
 	return nil
 }
diff --git a/pkg/hubble/server/serveroption/option.go b/pkg/hubble/server/serveroption/option.go
index 4fc4147aa92f..24ac60346e18 100644
--- a/pkg/hubble/server/serveroption/option.go
+++ b/pkg/hubble/server/serveroption/option.go
@@ -33,39 +33,16 @@ import (
 
 // Options stores all the configuration values for the hubble server.
 type Options struct {
-	Listeners       map[string]net.Listener
-	HealthService   healthpb.HealthServer
-	ObserverService observerpb.ObserverServer
-	PeerService     peerpb.PeerServer
+	TCPListener        net.Listener
+	UnixSocketListener net.Listener
+	HealthService      healthpb.HealthServer
+	ObserverService    observerpb.ObserverServer
+	PeerService        peerpb.PeerServer
 }
 
 // Option customizes then configuration of the hubble server.
 type Option func(o *Options) error
 
-// WithListeners configures listeners. Addresses that are prefixed with
-// 'unix://' are assumed to be UNIX domain sockets, in which case appropriate
-// permissions are tentatively set and the group owner is set to socketGroup.
-// Otherwise, the address is assumed to be TCP.
-func WithListeners(addresses []string) Option {
-	return func(o *Options) error {
-		var opt Option
-		for _, address := range addresses {
-			if strings.HasPrefix(address, "unix://") {
-				opt = WithUnixSocketListener(address)
-			} else {
-				opt = WithTCPListener(address)
-			}
-			if err := opt(o); err != nil {
-				for _, l := range o.Listeners {
-					l.Close()
-				}
-				return err
-			}
-		}
-		return nil
-	}
-}
-
 // WithTCPListener configures a TCP listener with the address.
 func WithTCPListener(address string) Option {
 	return func(o *Options) error {
@@ -73,11 +50,11 @@ func WithTCPListener(address string) Option {
 		if err != nil {
 			return err
 		}
-		if _, exist := o.Listeners[address]; exist {
+		if o.TCPListener != nil {
 			socket.Close()
 			return fmt.Errorf("listener already configured: %s", address)
 		}
-		o.Listeners[address] = socket
+		o.TCPListener = socket
 		return nil
 	}
 }
@@ -91,19 +68,21 @@ func WithUnixSocketListener(path string) Option {
 		unix.Unlink(socketPath)
 		socket, err := net.Listen("unix", socketPath)
 		if err != nil {
+			fmt.Println("MICHI 1", err)
 			return err
 		}
 		if os.Getuid() == 0 {
 			if err := api.SetDefaultPermissions(socketPath); err != nil {
+				fmt.Println("MICHI 2", err)
 				return err
 			}
 		}
-		if _, exist := o.Listeners[path]; exist {
+		if o.UnixSocketListener != nil {
 			socket.Close()
 			unix.Unlink(socketPath)
 			return fmt.Errorf("listener already configured: %s", path)
 		}
-		o.Listeners[path] = socket
+		o.UnixSocketListener = socket
 		return nil
 	}
 }