diff --git a/ca/ca_test.go b/ca/ca_test.go
index 63e9f26dd..438cf7a6d 100644
--- a/ca/ca_test.go
+++ b/ca/ca_test.go
@@ -709,7 +709,7 @@ func TestExtensions(t *testing.T) {
 
 	// With ca.enableMustStaple = false, should issue successfully and not add
 	// Must Staple.
-	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1)).Return(nil)
+	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1))
 	noStapleCert := sign(mustStapleCSR)
 	test.AssertEquals(t, signatureCountByPurpose("cert", ca.signatureCount), 1)
 	test.AssertEquals(t, countMustStaple(t, noStapleCert), 0)
@@ -717,20 +717,20 @@ func TestExtensions(t *testing.T) {
 	// With ca.enableMustStaple = true, a TLS feature extension should put a must-staple
 	// extension into the cert
 	ca.enableMustStaple = true
-	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1)).Return(nil)
+	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1))
 	singleStapleCert := sign(mustStapleCSR)
 	test.AssertEquals(t, signatureCountByPurpose("cert", ca.signatureCount), 1)
 	test.AssertEquals(t, countMustStaple(t, singleStapleCert), 1)
 
 	// Even if there are multiple TLS Feature extensions, only one extension should be included
-	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1)).Return(nil)
+	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1))
 	duplicateMustStapleCert := sign(duplicateMustStapleCSR)
 	test.AssertEquals(t, signatureCountByPurpose("cert", ca.signatureCount), 1)
 	test.AssertEquals(t, countMustStaple(t, duplicateMustStapleCert), 1)
 
 	// ... but if it doesn't ask for stapling, there should be an error
-	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1)).Return(nil)
-	stats.EXPECT().Inc(metricCSRExtensionTLSFeatureInvalid, int64(1)).Return(nil)
+	stats.EXPECT().Inc(metricCSRExtensionTLSFeature, int64(1))
+	stats.EXPECT().Inc(metricCSRExtensionTLSFeatureInvalid, int64(1))
 	ca.signatureCount.Reset()
 	_, err = ca.IssueCertificate(ctx, *tlsFeatureUnknownCSR, 1001)
 	test.AssertEquals(t, signatureCountByPurpose("cert", ca.signatureCount), 0)
@@ -739,7 +739,7 @@ func TestExtensions(t *testing.T) {
 
 	// Unsupported extensions should be silently ignored, having the same
 	// extensions as the TLS Feature cert above, minus the TLS Feature Extension
-	stats.EXPECT().Inc(metricCSRExtensionOther, int64(1)).Return(nil)
+	stats.EXPECT().Inc(metricCSRExtensionOther, int64(1))
 	unsupportedExtensionCert := sign(unsupportedExtensionCSR)
 	test.AssertEquals(t, signatureCountByPurpose("cert", ca.signatureCount), 1)
 	test.AssertEquals(t, len(unsupportedExtensionCert.Extensions), len(singleStapleCert.Extensions)-1)
diff --git a/metrics/mock_metrics/mock_scope.go b/metrics/mock_metrics/mock_scope.go
index 1af499d75..ff2661d62 100644
--- a/metrics/mock_metrics/mock_scope.go
+++ b/metrics/mock_metrics/mock_scope.go
@@ -31,30 +31,24 @@ func (_m *MockScope) EXPECT() *_MockScopeRecorder {
 	return _m.recorder
 }
 
-func (_m *MockScope) Gauge(_param0 string, _param1 int64) error {
-	ret := _m.ctrl.Call(_m, "Gauge", _param0, _param1)
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockScope) Gauge(_param0 string, _param1 int64) {
+	_m.ctrl.Call(_m, "Gauge", _param0, _param1)
 }
 
 func (_mr *_MockScopeRecorder) Gauge(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "Gauge", arg0, arg1)
 }
 
-func (_m *MockScope) GaugeDelta(_param0 string, _param1 int64) error {
-	ret := _m.ctrl.Call(_m, "GaugeDelta", _param0, _param1)
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockScope) GaugeDelta(_param0 string, _param1 int64) {
+	_m.ctrl.Call(_m, "GaugeDelta", _param0, _param1)
 }
 
 func (_mr *_MockScopeRecorder) GaugeDelta(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "GaugeDelta", arg0, arg1)
 }
 
-func (_m *MockScope) Inc(_param0 string, _param1 int64) error {
-	ret := _m.ctrl.Call(_m, "Inc", _param0, _param1)
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockScope) Inc(_param0 string, _param1 int64) {
+	_m.ctrl.Call(_m, "Inc", _param0, _param1)
 }
 
 func (_mr *_MockScopeRecorder) Inc(arg0, arg1 interface{}) *gomock.Call {
@@ -87,30 +81,24 @@ func (_mr *_MockScopeRecorder) NewScope(arg0 ...interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "NewScope", arg0...)
 }
 
-func (_m *MockScope) SetInt(_param0 string, _param1 int64) error {
-	ret := _m.ctrl.Call(_m, "SetInt", _param0, _param1)
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockScope) SetInt(_param0 string, _param1 int64) {
+	_m.ctrl.Call(_m, "SetInt", _param0, _param1)
 }
 
 func (_mr *_MockScopeRecorder) SetInt(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetInt", arg0, arg1)
 }
 
-func (_m *MockScope) Timing(_param0 string, _param1 int64) error {
-	ret := _m.ctrl.Call(_m, "Timing", _param0, _param1)
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockScope) Timing(_param0 string, _param1 int64) {
+	_m.ctrl.Call(_m, "Timing", _param0, _param1)
 }
 
 func (_mr *_MockScopeRecorder) Timing(arg0, arg1 interface{}) *gomock.Call {
 	return _mr.mock.ctrl.RecordCall(_mr.mock, "Timing", arg0, arg1)
 }
 
-func (_m *MockScope) TimingDuration(_param0 string, _param1 time.Duration) error {
-	ret := _m.ctrl.Call(_m, "TimingDuration", _param0, _param1)
-	ret0, _ := ret[0].(error)
-	return ret0
+func (_m *MockScope) TimingDuration(_param0 string, _param1 time.Duration) {
+	_m.ctrl.Call(_m, "TimingDuration", _param0, _param1)
 }
 
 func (_mr *_MockScopeRecorder) TimingDuration(arg0, arg1 interface{}) *gomock.Call {
diff --git a/metrics/scope.go b/metrics/scope.go
index a4c001c04..b3d19bbe7 100644
--- a/metrics/scope.go
+++ b/metrics/scope.go
@@ -12,12 +12,12 @@ import (
 type Scope interface {
 	NewScope(scopes ...string) Scope
 
-	Inc(stat string, value int64) error
-	Gauge(stat string, value int64) error
-	GaugeDelta(stat string, value int64) error
-	Timing(stat string, delta int64) error
-	TimingDuration(stat string, delta time.Duration) error
-	SetInt(stat string, value int64) error
+	Inc(stat string, value int64)
+	Gauge(stat string, value int64)
+	GaugeDelta(stat string, value int64)
+	Timing(stat string, delta int64)
+	TimingDuration(stat string, delta time.Duration)
+	SetInt(stat string, value int64)
 
 	MustRegister(...prometheus.Collector)
 }
@@ -55,40 +55,34 @@ func (s *promScope) NewScope(scopes ...string) Scope {
 }
 
 // Inc increments the given stat and adds the Scope's prefix to the name
-func (s *promScope) Inc(stat string, value int64) error {
+func (s *promScope) Inc(stat string, value int64) {
 	s.autoCounter(s.statName(stat)).Add(float64(value))
-	return nil
 }
 
 // Gauge sends a gauge stat and adds the Scope's prefix to the name
-func (s *promScope) Gauge(stat string, value int64) error {
+func (s *promScope) Gauge(stat string, value int64) {
 	s.autoGauge(s.statName(stat)).Set(float64(value))
-	return nil
 }
 
 // GaugeDelta sends the change in a gauge stat and adds the Scope's prefix to the name
-func (s *promScope) GaugeDelta(stat string, value int64) error {
+func (s *promScope) GaugeDelta(stat string, value int64) {
 	s.autoGauge(s.statName(stat)).Add(float64(value))
-	return nil
 }
 
 // Timing sends a latency stat and adds the Scope's prefix to the name
-func (s *promScope) Timing(stat string, delta int64) error {
+func (s *promScope) Timing(stat string, delta int64) {
 	s.autoSummary(s.statName(stat) + "_seconds").Observe(float64(delta))
-	return nil
 }
 
 // TimingDuration sends a latency stat as a time.Duration and adds the Scope's
 // prefix to the name
-func (s *promScope) TimingDuration(stat string, delta time.Duration) error {
+func (s *promScope) TimingDuration(stat string, delta time.Duration) {
 	s.autoSummary(s.statName(stat) + "_seconds").Observe(delta.Seconds())
-	return nil
 }
 
 // SetInt sets a stat's integer value and adds the Scope's prefix to the name
-func (s *promScope) SetInt(stat string, value int64) error {
+func (s *promScope) SetInt(stat string, value int64) {
 	s.autoGauge(s.statName(stat)).Set(float64(value))
-	return nil
 }
 
 // statName construct a name for a stat based on the prefix of this scope, plus
@@ -111,28 +105,22 @@ func (n noopScope) NewScope(scopes ...string) Scope {
 	return n
 }
 
-func (n noopScope) Inc(stat string, value int64) error {
-	return nil
+func (n noopScope) Inc(stat string, value int64) {
 }
 
-func (n noopScope) Gauge(stat string, value int64) error {
-	return nil
+func (n noopScope) Gauge(stat string, value int64) {
 }
 
-func (n noopScope) GaugeDelta(stat string, value int64) error {
-	return nil
+func (n noopScope) GaugeDelta(stat string, value int64) {
 }
 
-func (n noopScope) Timing(stat string, delta int64) error {
-	return nil
+func (n noopScope) Timing(stat string, delta int64) {
 }
 
-func (n noopScope) TimingDuration(stat string, delta time.Duration) error {
-	return nil
+func (n noopScope) TimingDuration(stat string, delta time.Duration) {
 }
 
-func (n noopScope) SetInt(stat string, value int64) error {
-	return nil
+func (n noopScope) SetInt(stat string, value int64) {
 }
 
 func (n noopScope) MustRegister(...prometheus.Collector) {
diff --git a/publisher/publisher_test.go b/publisher/publisher_test.go
index 444c9029c..56d996255 100644
--- a/publisher/publisher_test.go
+++ b/publisher/publisher_test.go
@@ -308,8 +308,8 @@ func TestBasicSuccessful(t *testing.T) {
 	statName := pub.ctLogs[0].statName
 	log.Clear()
 	scope.EXPECT().NewScope(statName).Return(scope)
-	scope.EXPECT().Inc("Submits", int64(1)).Return(nil)
-	scope.EXPECT().TimingDuration("SubmitLatency", gomock.Any()).Return(nil)
+	scope.EXPECT().Inc("Submits", int64(1))
+	scope.EXPECT().TimingDuration("SubmitLatency", gomock.Any())
 	err = pub.SubmitToCT(ctx, leaf.Raw)
 	test.AssertNotError(t, err, "Certificate submission failed")
 	test.AssertEquals(t, len(log.GetAllMatching("Failed to.*")), 0)
@@ -318,8 +318,8 @@ func TestBasicSuccessful(t *testing.T) {
 	pub.issuerBundle = []ct.ASN1Cert{}
 	log.Clear()
 	scope.EXPECT().NewScope(statName).Return(scope)
-	scope.EXPECT().Inc("Submits", int64(1)).Return(nil)
-	scope.EXPECT().TimingDuration("SubmitLatency", gomock.Any()).Return(nil)
+	scope.EXPECT().Inc("Submits", int64(1))
+	scope.EXPECT().TimingDuration("SubmitLatency", gomock.Any())
 	err = pub.SubmitToCT(ctx, leaf.Raw)
 	test.AssertNotError(t, err, "Certificate submission failed")
 	test.AssertEquals(t, len(log.GetAllMatching("Failed to.*")), 0)
@@ -358,9 +358,9 @@ func TestUnexpectedError(t *testing.T) {
 
 	log.Clear()
 	scope.EXPECT().NewScope(statName).Return(scope)
-	scope.EXPECT().Inc("Submits", int64(1)).Return(nil)
-	scope.EXPECT().Inc("Errors", int64(1)).Return(nil)
-	scope.EXPECT().TimingDuration("SubmitLatency", gomock.Any()).Return(nil)
+	scope.EXPECT().Inc("Submits", int64(1))
+	scope.EXPECT().Inc("Errors", int64(1))
+	scope.EXPECT().TimingDuration("SubmitLatency", gomock.Any())
 	err = pub.SubmitToCT(ctx, leaf.Raw)
 	test.AssertNotError(t, err, "Certificate submission failed")
 	test.AssertEquals(t, len(log.GetAllMatching("Failed .*http://localhost:"+strconv.Itoa(port))), 1)
diff --git a/test.sh b/test.sh
index 58f7cfa0c..273b86154 100755
--- a/test.sh
+++ b/test.sh
@@ -212,7 +212,7 @@ fi
 if [[ "$RUN" =~ "errcheck" ]] ; then
   start_context "errcheck"
   run_and_expect_silence errcheck \
-    -ignore io:Write,os:Remove,net/http:Write,github.com/letsencrypt/boulder/metrics:.* \
+    -ignore io:Write,os:Remove,net/http:Write \
     $(echo ${TESTPATHS} | tr ' ' '\n' | grep -v test)
   end_context #errcheck
 fi
diff --git a/va/va_test.go b/va/va_test.go
index d77345832..28a897478 100644
--- a/va/va_test.go
+++ b/va/va_test.go
@@ -866,8 +866,8 @@ func TestPerformValidationInvalid(t *testing.T) {
 	defer ctrl.Finish()
 	mockScope := mock_metrics.NewMockScope(ctrl)
 	va.stats = mockScope
-	mockScope.EXPECT().TimingDuration("Validations.dns-01.invalid", gomock.Any()).Return(nil)
-	mockScope.EXPECT().Inc(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+	mockScope.EXPECT().TimingDuration("Validations.dns-01.invalid", gomock.Any())
+	mockScope.EXPECT().Inc(gomock.Any(), gomock.Any()).AnyTimes()
 
 	chalDNS := createChallenge(core.ChallengeTypeDNS01)
 	_, prob := va.PerformValidation(context.Background(), "foo.com", chalDNS, core.Authorization{})
@@ -881,8 +881,8 @@ func TestDNSValidationEmpty(t *testing.T) {
 	defer ctrl.Finish()
 	mockScope := mock_metrics.NewMockScope(ctrl)
 	va.stats = mockScope
-	mockScope.EXPECT().TimingDuration("Validations.dns-01.invalid", gomock.Any()).Return(nil)
-	mockScope.EXPECT().Inc(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+	mockScope.EXPECT().TimingDuration("Validations.dns-01.invalid", gomock.Any())
+	mockScope.EXPECT().Inc(gomock.Any(), gomock.Any()).AnyTimes()
 
 	chalDNS := createChallenge(core.ChallengeTypeDNS01)
 	_, prob := va.PerformValidation(
@@ -900,8 +900,8 @@ func TestPerformValidationValid(t *testing.T) {
 	defer ctrl.Finish()
 	mockScope := mock_metrics.NewMockScope(ctrl)
 	va.stats = mockScope
-	mockScope.EXPECT().TimingDuration("Validations.dns-01.valid", gomock.Any()).Return(nil)
-	mockScope.EXPECT().Inc(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+	mockScope.EXPECT().TimingDuration("Validations.dns-01.valid", gomock.Any())
+	mockScope.EXPECT().Inc(gomock.Any(), gomock.Any()).AnyTimes()
 
 	// create a challenge with well known token
 	chalDNS := core.DNSChallenge01()
@@ -1271,7 +1271,7 @@ func TestFallbackDialer(t *testing.T) {
 	va.stats = scope
 
 	// We expect the IPV4 Fallback stat to be incremented
-	scope.EXPECT().Inc("IPv4Fallback", int64(1)).Return(nil)
+	scope.EXPECT().Inc("IPv4Fallback", int64(1))
 
 	// The validation is expected to succeed with IPv6First enabled even though
 	// the V6 server doesn't exist because we fallback to the IPv4 address.
@@ -1324,7 +1324,7 @@ func TestFallbackTLS(t *testing.T) {
 	va.stats = scope
 
 	// We expect the IPV4 Fallback stat to be incremented
-	scope.EXPECT().Inc("IPv4Fallback", int64(1)).Return(nil)
+	scope.EXPECT().Inc("IPv4Fallback", int64(1))
 
 	// The validation is expected to succeed now that IPv6First is enabled by the
 	// fallback to the IPv4 address that has a test server waiting