diff --git a/log/format.go b/log/format.go
index 6a03013b81..fb476b73e3 100644
--- a/log/format.go
+++ b/log/format.go
@@ -32,16 +32,20 @@ var locationTrims = []string{
 // PrintOrigins sets or unsets log location (file:line) printing for terminal
 // format output.
 func PrintOrigins(print bool) {
-	locationEnabled.Store(print)
+	if print {
+		atomic.StoreUint32(&locationEnabled, 1)
+	} else {
+		atomic.StoreUint32(&locationEnabled, 0)
+	}
 }
 
 // locationEnabled is an atomic flag controlling whether the terminal formatter
 // should append the log locations too when printing entries.
-var locationEnabled atomic.Bool
+var locationEnabled uint32
 
 // locationLength is the maxmimum path length encountered, which all logs are
 // padded to to aid in alignment.
-var locationLength atomic.Uint32
+var locationLength uint32
 
 // fieldPadding is a global map with maximum field value lengths seen until now
 // to allow padding log contexts in a bit smarter way.
@@ -105,17 +109,17 @@ func TerminalFormat(usecolor bool) Format {
 
 		b := &bytes.Buffer{}
 		lvl := r.Lvl.AlignedString()
-		if locationEnabled.Load() {
+		if atomic.LoadUint32(&locationEnabled) != 0 {
 			// Log origin printing was requested, format the location path and line number
 			location := fmt.Sprintf("%+v", r.Call)
 			for _, prefix := range locationTrims {
 				location = strings.TrimPrefix(location, prefix)
 			}
 			// Maintain the maximum location length for fancyer alignment
-			align := int(locationLength.Load())
+			align := int(atomic.LoadUint32(&locationLength))
 			if align < len(location) {
 				align = len(location)
-				locationLength.Store(uint32(align))
+				atomic.StoreUint32(&locationLength, uint32(align))
 			}
 			padding := strings.Repeat(" ", align-len(location))
 
diff --git a/log/handler_glog.go b/log/handler_glog.go
index 6db5f1a4c9..b5186d4b27 100644
--- a/log/handler_glog.go
+++ b/log/handler_glog.go
@@ -39,9 +39,9 @@ var errTraceSyntax = errors.New("expect file.go:234")
 type GlogHandler struct {
 	origin Handler // The origin handler this wraps
 
-	level     atomic.Uint32 // Current log level, atomically accessible
-	override  atomic.Bool   // Flag whether overrides are used, atomically accessible
-	backtrace atomic.Bool   // Flag whether backtrace location is set
+	level     uint32 // Current log level, atomically accessible
+	override  uint32 // Flag whether overrides are used, atomically accessible
+	backtrace uint32 // Flag whether backtrace location is set
 
 	patterns  []pattern       // Current list of patterns to override with
 	siteCache map[uintptr]Lvl // Cache of callsite pattern evaluations
@@ -72,7 +72,7 @@ type pattern struct {
 // Verbosity sets the glog verbosity ceiling. The verbosity of individual packages
 // and source files can be raised using Vmodule.
 func (h *GlogHandler) Verbosity(level Lvl) {
-	h.level.Store(uint32(level))
+	atomic.StoreUint32(&h.level, uint32(level))
 }
 
 // Vmodule sets the glog verbosity pattern.
@@ -138,7 +138,7 @@ func (h *GlogHandler) Vmodule(ruleset string) error {
 
 	h.patterns = filter
 	h.siteCache = make(map[uintptr]Lvl)
-	h.override.Store(len(filter) != 0)
+	atomic.StoreUint32(&h.override, uint32(len(filter)))
 
 	return nil
 }
@@ -171,7 +171,7 @@ func (h *GlogHandler) BacktraceAt(location string) error {
 	defer h.lock.Unlock()
 
 	h.location = location
-	h.backtrace.Store(len(location) > 0)
+	atomic.StoreUint32(&h.backtrace, uint32(len(location)))
 
 	return nil
 }
@@ -180,7 +180,7 @@ func (h *GlogHandler) BacktraceAt(location string) error {
 // and backtrace filters, finally emitting it if either allow it through.
 func (h *GlogHandler) Log(r *Record) error {
 	// If backtracing is requested, check whether this is the callsite
-	if h.backtrace.Load() {
+	if atomic.LoadUint32(&h.backtrace) > 0 {
 		// Everything below here is slow. Although we could cache the call sites the
 		// same way as for vmodule, backtracing is so rare it's not worth the extra
 		// complexity.
@@ -198,11 +198,11 @@ func (h *GlogHandler) Log(r *Record) error {
 		}
 	}
 	// If the global log level allows, fast track logging
-	if h.level.Load() >= uint32(r.Lvl) {
+	if atomic.LoadUint32(&h.level) >= uint32(r.Lvl) {
 		return h.origin.Log(r)
 	}
 	// If no local overrides are present, fast track skipping
-	if !h.override.Load() {
+	if atomic.LoadUint32(&h.override) == 0 {
 		return nil
 	}
 	// Check callsite cache for previously calculated log levels