diff --git a/cmd/testrunner/main.go b/cmd/testrunner/main.go
index 3910b9d..49ee0bc 100644
--- a/cmd/testrunner/main.go
+++ b/cmd/testrunner/main.go
@@ -12,6 +12,7 @@
 	"flag"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"time"
@@ -30,9 +31,6 @@
 	// The username used to authenticate with the Fuchsia device.
 	sshUser = "fuchsia"
 
-	// The test output directory to create on the Fuchsia device.
-	fuchsiaOutputDir = "/data/infra/testrunner"
-
 	// The filename to use for log_listener's stdout captured during Fuchsia tests.
 	syslogStdoutFilename = "syslog-stdout.txt"
 
@@ -215,40 +213,15 @@
 }
 
 func runFuchsiaTests(tests []testsharder.Test, output *TestRunnerOutput, devCtx *botanist.DeviceContext) error {
-	if len(tests) == 0 {
-		return nil
-	} else if devCtx == nil {
+	if devCtx == nil {
 		return errors.New("no DeviceContext set; cannot execute fuchsia tests")
 	}
 
-	// Initialize the connection to the Fuchsia device.
-	sshClient, err := sshIntoNode(devCtx.Nodename, devCtx.SSHKey)
+	tester, err := NewFuchsiaTester(*devCtx)
 	if err != nil {
-		return fmt.Errorf("failed to connect to node %q: %v", devCtx.Nodename, err)
+		return fmt.Errorf("failed to initialize fuchsia tester: %v", err)
 	}
-	defer sshClient.Close()
-
-	fuchsiaTester := &FuchsiaTester{
-		remoteOutputDir: fuchsiaOutputDir,
-		delegate: &SSHTester{
-			client: sshClient,
-		},
-	}
-
-	// Record log_listener output. This goes into the output archive as "syslog.txt"
-	session, err := sshClient.NewSession()
-	if err != nil {
-		return err
-	}
-	defer session.Close()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	syslogStdout := new(bytes.Buffer)
-	syslogStderr := new(bytes.Buffer)
-	runner := &testrunner.SSHRunner{Session: session}
-	go runner.Run(ctx, []string{"bin/log_listener"}, syslogStdout, syslogStderr)
+	defer tester.Close()
 
 	// Ensure the syslog is always included in the output, even if tests fail.
 	// TODO(IN-824): Run fuchsia/linux/mac tests in go-routines and emit errors on channels.
@@ -257,16 +230,28 @@
 			return
 		}
 
-		if err := output.Tar.TarFile(syslogStdout.Bytes(), syslogStdoutFilename); err != nil {
+		stdout, stderr := tester.SyslogOutput()
+		stdoutBytes, err := ioutil.ReadAll(stdout)
+		if err != nil {
+			log.Println(err)
+			return
+		}
+		stderrBytes, err := ioutil.ReadAll(stderr)
+		if err != nil {
+			log.Println(err)
+			return
+		}
+
+		if err := output.Tar.TarFile(stdoutBytes, syslogStdoutFilename); err != nil {
 			log.Println(err)
 		}
 
-		if err := output.Tar.TarFile(syslogStderr.Bytes(), syslogStderrFilename); err != nil {
+		if err := output.Tar.TarFile(stderrBytes, syslogStderrFilename); err != nil {
 			log.Println(err)
 		}
 	}()
 
-	return runTests(tests, fuchsiaTester.Test, output)
+	return runTests(tests, tester.Test, output)
 }
 
 func runTests(tests []testsharder.Test, tester Tester, output *TestRunnerOutput) error {
diff --git a/cmd/testrunner/tester.go b/cmd/testrunner/tester.go
index f16720b..bc6b77f 100644
--- a/cmd/testrunner/tester.go
+++ b/cmd/testrunner/tester.go
@@ -5,15 +5,23 @@
 package main
 
 import (
+	"bytes"
 	"context"
+	"fmt"
 	"io"
 	"path"
 
+	"fuchsia.googlesource.com/tools/botanist"
 	"fuchsia.googlesource.com/tools/testrunner"
 	"fuchsia.googlesource.com/tools/testsharder"
 	"golang.org/x/crypto/ssh"
 )
 
+const (
+	// The test output directory to create on the Fuchsia device.
+	fuchsiaOutputDir = "/data/infra/testrunner"
+)
+
 // Tester is executes a Test.
 type Tester func(context.Context, testsharder.Test, io.Writer, io.Writer) error
 
@@ -40,11 +48,20 @@
 }
 
 // SSHTester executes tests over an SSH connection. It assumes the test.Command
-// contains the command line to execute on the remote machine.
+// contains the command line to execute on the remote machine. The caller should Close() the
+// tester when finished. Once closed, this object can no longer be used.
 type SSHTester struct {
 	client *ssh.Client
 }
 
+func NewSSHTester(devCtx botanist.DeviceContext) (*SSHTester, error) {
+	client, err := sshIntoNode(devCtx.Nodename, devCtx.SSHKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to node %q: %v", devCtx.Nodename, err)
+	}
+	return &SSHTester{client: client}, nil
+}
+
 func (t *SSHTester) Test(ctx context.Context, test testsharder.Test, stdout io.Writer, stderr io.Writer) error {
 	session, err := t.client.NewSession()
 	if err != nil {
@@ -56,6 +73,15 @@
 	return runner.Run(ctx, test.Command, stdout, stderr)
 }
 
+// Close stops this SSHTester.  The underlying SSH connection is terminated.  The object
+// is no longer usable after calling this method.
+func (t *SSHTester) Close() error {
+	return t.client.Close()
+}
+
+// FuchsiaTester executes tests on remote Fuchsia devices. The caller should Close() the
+// tester when finished. Once closed, this object can no longer be used.
+//
 // This is a hack. We have to run Fuchsia tests using `runtests` on the remote device
 // because there are many ways to execute Fuchsia tests and runtests already does this
 // correctly. This wrapper around SSHTester is meant to keep SSHTester free of OS-specific
@@ -63,6 +89,28 @@
 type FuchsiaTester struct {
 	remoteOutputDir string
 	delegate        *SSHTester
+	remoteSyslog    *remoteSyslog
+}
+
+// NewFuchsiaTester creates a FuchsiaTester object and starts a log_listener process on
+// the remote device. The log_listener output can be read from SysLogOutput().
+func NewFuchsiaTester(devCtx botanist.DeviceContext) (*FuchsiaTester, error) {
+	delegate, err := NewSSHTester(devCtx)
+	if err != nil {
+		return nil, err
+	}
+
+	tester := &FuchsiaTester{
+		remoteOutputDir: fuchsiaOutputDir,
+		delegate:        delegate,
+	}
+
+	tester.remoteSyslog, err = newRemoteSyslog(context.Background(), delegate.client)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start remote log_listener process: %v", err)
+	}
+
+	return tester, nil
 }
 
 func (t *FuchsiaTester) Test(ctx context.Context, test testsharder.Test, stdout io.Writer, stderr io.Writer) error {
@@ -70,3 +118,60 @@
 	test.Command = []string{"runtests", "-t", name, "-o", t.remoteOutputDir + "runtests"}
 	return t.delegate.Test(ctx, test, stdout, stderr)
 }
+
+// SysLogOutput returns the stdout and stderr streams of the remote log_listener process.
+func (t *FuchsiaTester) SyslogOutput() (stdout, stderr *bytes.Reader) {
+	return t.remoteSyslog.stdout(), t.remoteSyslog.stderr()
+}
+
+// Close stops this FuchsiaTester.  The remote log_listener process is terminated along
+// with the underlying SSH connection.  The object is no longer usable after calling this
+// method.
+func (t *FuchsiaTester) Close() error {
+	if err := t.remoteSyslog.stop(); err != nil {
+		return fmt.Errorf("failed to terminate remote log_listener: %v", err)
+	}
+	if err := t.delegate.Close(); err != nil {
+		return fmt.Errorf("failed to close delegate ssh runner: %v", err)
+	}
+	return nil
+}
+
+// A handle to a remote log_listener process on some Fuchsia device.
+type remoteSyslog struct {
+	stdoutBuf *bytes.Buffer
+	stderrBuf *bytes.Buffer
+	session   *ssh.Session
+}
+
+// Starts a remote process on the Fuchsia device to run log_listener. The output of the
+// process is written to the given stdout and stderr streams. The process will terminate
+// when the FuchsiaTester is Close().
+func newRemoteSyslog(ctx context.Context, client *ssh.Client) (*remoteSyslog, error) {
+	session, err := client.NewSession()
+	if err != nil {
+		return nil, err
+	}
+
+	sl := &remoteSyslog{
+		session:   session,
+		stdoutBuf: new(bytes.Buffer),
+		stderrBuf: new(bytes.Buffer),
+	}
+
+	runner := &testrunner.SSHRunner{Session: session}
+	go runner.Run(ctx, []string{"bin/log_listener"}, sl.stdoutBuf, sl.stderrBuf)
+	return sl, nil
+}
+
+func (sl *remoteSyslog) stdout() *bytes.Reader {
+	return bytes.NewReader(sl.stdoutBuf.Bytes())
+}
+
+func (sl *remoteSyslog) stderr() *bytes.Reader {
+	return bytes.NewReader(sl.stderrBuf.Bytes())
+}
+
+func (sl *remoteSyslog) stop() error {
+	return sl.session.Close()
+}
diff --git a/cmd/testrunner/tester_test.go b/cmd/testrunner/tester_test.go
index b40de24..b152c4e 100644
--- a/cmd/testrunner/tester_test.go
+++ b/cmd/testrunner/tester_test.go
@@ -15,21 +15,50 @@
 )
 
 func TestTester(t *testing.T) {
-	tester := &SubprocessTester{}
-	cases := []testCase{
+	cases := []struct {
+		name   string
+		test   testsharder.Test
+		stdout string
+		stderr string
+	}{
 		{
-			name:   "should run a command a local subprocess",
-			tester: tester.Test,
+			name: "should run a command a local subprocess",
 			test: testsharder.Test{
 				Name: "hello_world_test",
 				// Assumes that we're running on a Unix system.
 				Command: []string{"/bin/echo", "Hello world!"},
 			},
-			expectedOutput: "Hello world!",
+			stdout: "Hello world!",
 		},
 	}
 
-	runTestCases(t, cases)
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			tester := &SubprocessTester{}
+
+			stdout := new(bytes.Buffer)
+			stderr := new(bytes.Buffer)
+
+			if err := tester.Test(context.Background(), tt.test, stdout, stderr); err != nil {
+				t.Errorf("failed to exected test %q: %v", tt.test.Name, err)
+				return
+			}
+
+			// Compare stdout
+			actual := strings.TrimSpace(stdout.String())
+			expected := tt.stdout
+			if actual != expected {
+				t.Errorf("got stdout %q but wanted %q", actual, expected)
+			}
+
+			// Compare stderr
+			actual = strings.TrimSpace(stderr.String())
+			expected = tt.stderr
+			if actual != expected {
+				t.Errorf("got stderr %q but wanted %q", actual, expected)
+			}
+		})
+	}
 }
 
 // Verifies that SSHTester can execute tests on a remote device. These tests are
@@ -44,57 +73,73 @@
 		t.Fatal(err)
 	}
 
-	client, err := sshIntoNode(devCtx.Nodename, devCtx.SSHKey)
-	if err != nil {
-		t.Fatalf("failed to connect to node '%s': %v", devCtx.Nodename, err)
-	}
-
-	tester := &SSHTester{client: client}
-	cases := []testCase{
+	cases := []struct {
+		name   string
+		tests  []testsharder.Test
+		stdout string
+		stderr string
+	}{
 		{
-			name:   "should run a command over SSH",
-			tester: tester.Test,
-			test: testsharder.Test{
-				Name: "hello_world_test",
-				// Just 'echo' and not '/bin/echo' because this assumes we're running on
-				// Fuchsia.
-				Command: []string{"echo", "Hello world!"},
+			name: "should run a command over SSH",
+			tests: []testsharder.Test{
+				{
+					Name: "hello_world_test",
+					// Just 'echo' and not '/bin/echo' because this assumes we're running on
+					// Fuchsia.
+					Command: []string{"echo", "Hello world!"},
+				},
 			},
-			expectedOutput: "Hello world!",
+			stdout: "Hello world!",
 		},
 		{
-			name:   "should run successive commands over SSH",
-			tester: tester.Test,
-			test: testsharder.Test{
-				Name:    "hello_again_test",
-				Command: []string{"echo", "Hello again!"},
+			name: "should run successive commands over SSH",
+			tests: []testsharder.Test{
+				{
+					Name:    "test_1",
+					Command: []string{"echo", "this is test 1"},
+				},
+				{
+					Name:    "test_2",
+					Command: []string{"echo", "this is test 2"},
+				},
 			},
-			expectedOutput: "Hello again!",
+			stdout: "this is test 1\nthis is test 2",
 		},
 	}
 
-	runTestCases(t, cases)
-}
-
-type testCase struct {
-	name           string
-	test           testsharder.Test
-	tester         Tester
-	expectedOutput string
-	expectError    bool
-}
-
-func runTestCases(t *testing.T, cases []testCase) {
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			output := new(bytes.Buffer)
-			err := tt.tester(context.Background(), tt.test, output, output)
-			if tt.expectError && err == nil {
-				t.Fatalf("%s: got nil, wanted error", tt.name)
-			} else if !tt.expectError && err != nil {
-				t.Fatalf("%s: got err '%v', wanted nil", tt.name, err)
-			} else if tt.expectedOutput != strings.TrimSpace(output.String()) {
-				t.Fatalf("%s: got output: '%s', want: '%s'", tt.name, output.String(), tt.expectedOutput)
+			tester, err := NewSSHTester(*devCtx)
+			if err != nil {
+				t.Errorf("failed to intialize tester: %v", err)
+				return
+			}
+
+			stdout := new(bytes.Buffer)
+			stderr := new(bytes.Buffer)
+			for _, test := range tt.tests {
+				if err := tester.Test(context.Background(), test, stdout, stderr); err != nil {
+					t.Error(err)
+					return
+				}
+			}
+
+			if err := tester.Close(); err != nil {
+				t.Fatalf("failed to close tester: %v", err)
+			}
+
+			// Compare stdout
+			actual := strings.TrimSpace(stdout.String())
+			expected := tt.stdout
+			if actual != expected {
+				t.Errorf("got stdout %q but wanted %q", actual, expected)
+			}
+
+			// Compare stderr
+			actual = strings.TrimSpace(stderr.String())
+			expected = tt.stderr
+			if actual != expected {
+				t.Errorf("got stderr %q but wanted %q", actual, expected)
 			}
 		})
 	}