diff --git a/interface.go b/interface.go
index a430d98f..bbefcf27 100644
--- a/interface.go
+++ b/interface.go
@@ -50,9 +50,9 @@ type Stream interface {
 	// It must not be called after calling CancelWrite.
 	io.Closer
 	// CancelWrite aborts sending on this stream.
-	// It must not be called after Close.
 	// Data already written, but not yet delivered to the peer is not guaranteed to be delivered reliably.
 	// Write will unblock immediately, and future calls to Write will fail.
+	// When called multiple times or after closing the stream it is a no-op.
 	CancelWrite(ErrorCode) error
 	// CancelRead aborts receiving on this stream.
 	// It will ask the peer to stop transmitting stream data.
diff --git a/send_stream.go b/send_stream.go
index 6be4b898..257ff12f 100644
--- a/send_stream.go
+++ b/send_stream.go
@@ -254,12 +254,9 @@ func (s *sendStream) CancelWrite(errorCode protocol.ApplicationErrorCode) error
 
 // must be called after locking the mutex
 func (s *sendStream) cancelWriteImpl(errorCode protocol.ApplicationErrorCode, writeErr error) (bool /*completed */, error) {
-	if s.canceledWrite {
+	if s.canceledWrite || s.finishedWriting {
 		return false, nil
 	}
-	if s.finishedWriting {
-		return false, fmt.Errorf("CancelWrite for closed stream %d", s.streamID)
-	}
 	s.canceledWrite = true
 	s.cancelWriteErr = writeErr
 	s.signalWrite()
diff --git a/send_stream_test.go b/send_stream_test.go
index 01814d84..50b039df 100644
--- a/send_stream_test.go
+++ b/send_stream_test.go
@@ -589,27 +589,23 @@ var _ = Describe("Send Stream", func() {
 			It("doesn't allow further calls to Write", func() {
 				mockSender.EXPECT().queueControlFrame(gomock.Any())
 				mockSender.EXPECT().onStreamCompleted(streamID)
-				err := str.CancelWrite(1234)
-				Expect(err).ToNot(HaveOccurred())
-				_, err = strWithTimeout.Write([]byte("foobar"))
+				Expect(str.CancelWrite(1234)).To(Succeed())
+				_, err := strWithTimeout.Write([]byte("foobar"))
 				Expect(err).To(MatchError("Write on stream 1337 canceled with error code 1234"))
 			})
 
 			It("only cancels once", func() {
-				mockSender.EXPECT().queueControlFrame(gomock.Any())
+				mockSender.EXPECT().queueControlFrame(&wire.ResetStreamFrame{StreamID: streamID, ErrorCode: 1234})
 				mockSender.EXPECT().onStreamCompleted(streamID)
-				err := str.CancelWrite(1234)
-				Expect(err).ToNot(HaveOccurred())
-				err = str.CancelWrite(4321)
-				Expect(err).ToNot(HaveOccurred())
+				Expect(str.CancelWrite(1234)).To(Succeed())
+				Expect(str.CancelWrite(4321)).To(Succeed())
 			})
 
-			It("doesn't cancel when the stream was already closed", func() {
+			It("doesn't do anything when the stream was already closed", func() {
 				mockSender.EXPECT().onHasStreamData(streamID)
-				err := str.Close()
-				Expect(err).ToNot(HaveOccurred())
-				err = str.CancelWrite(123)
-				Expect(err).To(MatchError("CancelWrite for closed stream 1337"))
+				Expect(str.Close()).To(Succeed())
+				// don't EXPECT any calls to queueControlFrame
+				Expect(str.CancelWrite(123)).To(Succeed())
 			})
 		})