diff --git a/services/responders.go b/services/responders.go
index fa1674c59..700307d7c 100644
--- a/services/responders.go
+++ b/services/responders.go
@@ -130,7 +130,7 @@ func (resp *ResponderService) ShouldRun() bool {
 	return resp.cfg.RalsCfg().Enabled
 }
 
-// RegisterSyncChan used by dependent subsystems to register a chanel to reload only the responder(thread safe)
+// RegisterSyncChan used by dependent subsystems to register a channel to reload only the responder(thread safe)
 func (resp *ResponderService) RegisterSyncChan(srv string, c chan *engine.Responder) {
 	resp.Lock()
 	resp.syncChans[srv] = c
@@ -140,7 +140,7 @@ func (resp *ResponderService) RegisterSyncChan(srv string, c chan *engine.Respon
 	resp.Unlock()
 }
 
-// UnregisterSyncChan used by dependent subsystems to unregister a chanel
+// UnregisterSyncChan used by dependent subsystems to unregister a channel
 func (resp *ResponderService) UnregisterSyncChan(srv string) {
 	resp.Lock()
 	c, has := resp.syncChans[srv]
@@ -151,7 +151,7 @@ func (resp *ResponderService) UnregisterSyncChan(srv string) {
 	resp.Unlock()
 }
 
-// sync sends the responder over syncChansv (not thrad safe)
+// sync sends the responder over syncChansv (not thread safe)
 func (resp *ResponderService) sync() {
 	if resp.isRunning() {
 		for _, c := range resp.syncChans {
diff --git a/services/responders_it_test.go b/services/responders_it_test.go
index ea1c7a4b1..be959ceac 100644
--- a/services/responders_it_test.go
+++ b/services/responders_it_test.go
@@ -75,7 +75,9 @@ func TestResponderSReload(t *testing.T) {
 	if err != nil {
 		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
 	}
-
+	srv.syncChans = map[string]chan *engine.Responder{
+		"srv": make(chan *engine.Responder, 1),
+	}
 	err = srv.Shutdown()
 	if err != nil {
 		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
@@ -86,3 +88,57 @@ func TestResponderSReload(t *testing.T) {
 	}
 
 }
+func TestResponderSReload2(t *testing.T) {
+	// utils.Logger.SetLogLevel(7)
+	cfg := config.NewDefaultCGRConfig()
+
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	cfg.ThresholdSCfg().Enabled = true
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	server := cores.NewServer(nil)
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
+	internalChan := make(chan rpcclient.ClientConnector, 1)
+	srv := NewResponderService(cfg, server, internalChan,
+		shdChan, anz, srvDep)
+
+	srvName := srv.ServiceName()
+	if srvName != utils.ResponderS {
+		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ResponderS, srvName)
+	}
+
+	if srv.IsRunning() {
+		t.Errorf("Expected service to be down")
+	}
+
+	err := srv.Start()
+	if err != nil {
+		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
+	}
+
+	if !srv.IsRunning() {
+		t.Errorf("Expected service to be running")
+	}
+
+	err = srv.Start()
+	if err != utils.ErrServiceAlreadyRunning {
+		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ErrServiceAlreadyRunning, err)
+	}
+
+	srv.syncChans = map[string]chan *engine.Responder{
+		"srv": make(chan *engine.Responder, 1),
+	}
+	srv.resp = &engine.Responder{
+		ShdChan:          shdChan,
+		Timeout:          1,
+		Timezone:         "",
+		MaxComputedUsage: nil,
+	}
+	srv.sync()
+	srv.RegisterSyncChan("srv", make(chan *engine.Responder, 1))
+	srv.resp = nil
+
+}