diff --git a/cmd/query/app/flags.go b/cmd/query/app/flags.go
index 65907e8f4cb..64d4a2ae9c8 100644
--- a/cmd/query/app/flags.go
+++ b/cmd/query/app/flags.go
@@ -18,6 +18,7 @@ package app
 import (
 	"bufio"
 	"flag"
+	"fmt"
 	"io"
 	"net/http"
 	"net/textproto"
@@ -72,15 +73,22 @@ func (qOpts *QueryOptions) InitFromViper(v *viper.Viper, logger *zap.Logger) *Qu
 	qOpts.StaticAssets = v.GetString(queryStaticFiles)
 	qOpts.UIConfig = v.GetString(queryUIConfig)
 	qOpts.BearerTokenPropagation = v.GetBool(queryTokenPropagation)
-	qOpts.AdditionalHeaders = stringSliceAsHeader(v.GetStringSlice(queryAdditionalHeaders), logger)
+
+	stringSlice := v.GetStringSlice(queryAdditionalHeaders)
+	headers, err := stringSliceAsHeader(stringSlice)
+	if err != nil {
+		logger.Error("Failed to parse headers", zap.Strings("slice", stringSlice), zap.Error(err))
+	} else {
+		qOpts.AdditionalHeaders = headers
+	}
 	return qOpts
 }
 
 // stringSliceAsHeader parses a slice of strings and returns a http.Header.
 //  Each string in the slice is expected to be in the format "key: value"
-func stringSliceAsHeader(slice []string, logger *zap.Logger) http.Header {
+func stringSliceAsHeader(slice []string) (http.Header, error) {
 	if len(slice) == 0 {
-		return nil
+		return nil, nil
 	}
 
 	allHeaders := strings.Join(slice, "\r\n")
@@ -90,9 +98,8 @@ func stringSliceAsHeader(slice []string, logger *zap.Logger) http.Header {
 
 	header, err := tp.ReadMIMEHeader()
 	if err != nil && err != io.EOF {
-		logger.Error("Failed to parse headers", zap.Strings("headers", slice))
-		return nil
+		return nil, fmt.Errorf("failed to parse headers")
 	}
 
-	return http.Header(header)
+	return http.Header(header), nil
 }
diff --git a/cmd/query/app/flags_test.go b/cmd/query/app/flags_test.go
index 15faad4577d..00e365ab84b 100644
--- a/cmd/query/app/flags_test.go
+++ b/cmd/query/app/flags_test.go
@@ -41,27 +41,34 @@ func TestQueryBuilderFlags(t *testing.T) {
 	assert.Equal(t, "/jaeger", qOpts.BasePath)
 	assert.Equal(t, 80, qOpts.Port)
 	assert.Equal(t, http.Header{
-	           "Access-Control-Allow-Origin": []string{"blerg"}, 
-	           "Whatever": []string{"thing"}
-	       }, qOpts.AdditionalHeaders)
+		"Access-Control-Allow-Origin": []string{"blerg"},
+		"Whatever":                    []string{"thing"},
+	}, qOpts.AdditionalHeaders)
 }
 
 func TestStringSliceAsHeader(t *testing.T) {
 	headers := []string{
-	    "Access-Control-Allow-Origin: https://mozilla.org",
+		"Access-Control-Allow-Origin: https://mozilla.org",
 		"Access-Control-Expose-Headers: X-My-Custom-Header",
 		"Access-Control-Expose-Headers: X-Another-Custom-Header",
 	}
 
-	parsedHeaders := stringSliceAsHeader(headers, zap.NewNop())
+	parsedHeaders, err := stringSliceAsHeader(headers)
 
 	assert.Equal(t, []string{"https://mozilla.org"}, parsedHeaders["Access-Control-Allow-Origin"])
 	assert.Equal(t, []string{"X-My-Custom-Header", "X-Another-Custom-Header"}, parsedHeaders["Access-Control-Expose-Headers"])
+	assert.NoError(t, err)
 
 	malformedHeaders := append(headers, "this is not a valid header")
-	parsedHeaders = stringSliceAsHeader(malformedHeaders, zap.NewNop())
+	parsedHeaders, err = stringSliceAsHeader(malformedHeaders)
 	assert.Nil(t, parsedHeaders)
+	assert.Error(t, err)
 
-	parsedHeaders = stringSliceAsHeader([]string{}, zap.NewNop())
+	parsedHeaders, err = stringSliceAsHeader([]string{})
 	assert.Nil(t, parsedHeaders)
+	assert.NoError(t, err)
+
+	parsedHeaders, err = stringSliceAsHeader(nil)
+	assert.Nil(t, parsedHeaders)
+	assert.NoError(t, err)
 }