diff --git a/cmd/ginvalid/main.go b/cmd/ginvalid/main.go
index 8c5052c..5d02519 100644
--- a/cmd/ginvalid/main.go
+++ b/cmd/ginvalid/main.go
@@ -62,13 +62,13 @@ func startupCheck(srvcfg config.ServerCfg) {
 		os.Exit(-1)
 	}
 
-	log.ShowWrite("[Warmup] using temp directory: '%s'", srvcfg.Dir.Temp)
-	log.ShowWrite("[Warmup] using results directory '%s'", srvcfg.Dir.Result)
+	log.ShowWrite("[Warmup] using temp directory: %q", srvcfg.Dir.Temp)
+	log.ShowWrite("[Warmup] using results directory %q", srvcfg.Dir.Result)
 
 	// Check bids-validator is installed
 	outstr, err := helpers.AppVersionCheck(srvcfg.Exec.BIDS)
 	if err != nil {
-		log.ShowWrite("[Error] checking bids-validator '%s'", err.Error())
+		log.ShowWrite("[Error] checking bids-validator %q", err.Error())
 		os.Exit(-1)
 	}
 	log.ShowWrite("[Warmup] using bids-validator v%s", strings.TrimSpace(outstr))
@@ -110,7 +110,7 @@ func commcheck(srvcfg config.ServerCfg) {
 	cli := ginclient.New("gin")
 	err = cli.Login(srvcfg.Settings.GINUser, srvcfg.Settings.GINPassword, srvcfg.Settings.ClientID)
 	if err != nil {
-		log.ShowWrite("Failed to login to GIN server: %s", err.Error())
+		log.ShowWrite("[Error] Failed to login to GIN server: %s", err.Error())
 		os.Exit(-1)
 	}
 	log.ShowWrite("[Warmup] GIN server configuration OK")
@@ -171,7 +171,7 @@ func main() {
 		port = srvcfg.Settings.Port
 	}
 	port = fmt.Sprintf(":%s", port)
-	log.ShowWrite("[Warmup] using port: '%s'", port)
+	log.ShowWrite("[Warmup] using port: %q", port)
 
 	log.ShowWrite("[Warmup] registering routes")
 	router := mux.NewRouter()
diff --git a/internal/helpers/utils.go b/internal/helpers/utils.go
index ff2ffd3..83a0009 100644
--- a/internal/helpers/utils.go
+++ b/internal/helpers/utils.go
@@ -12,10 +12,10 @@ func ValidDirectory(path string) bool {
 	var fi os.FileInfo
 	var err error
 	if fi, err = os.Stat(path); err != nil {
-		log.ShowWrite("[Error] checking directory '%s': '%s'\n", path, err.Error())
+		log.ShowWrite("[Error] checking directory %q: %q", path, err.Error())
 		return false
 	} else if !fi.IsDir() {
-		log.ShowWrite("[Error] invalid directory '%s'\n", fi.Name())
+		log.ShowWrite("[Error] invalid directory %q", fi.Name())
 		return false
 	}
 	return true
diff --git a/internal/web/fail.go b/internal/web/fail.go
index 7903494..aeb45aa 100644
--- a/internal/web/fail.go
+++ b/internal/web/fail.go
@@ -13,21 +13,21 @@ import (
 // fail logs an error and renders an error page with the given message,
 // returning the given status code to the user.
 func fail(w http.ResponseWriter, r *http.Request, status int, message string) {
-	log.Write("[error] %s", message)
+	log.ShowWrite("[Info] displaying error message %s", message)
 	w.WriteHeader(status)
 
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.Write("[Error] failed to parse html layout page. Displaying error message without layout.")
+		log.ShowWrite("[Error] failed to parse html layout page. Displaying error message without layout: %s", err.Error())
 		tmpl = template.New("content")
 	}
 	tmpl, err = tmpl.Parse(templates.Fail)
 	if err != nil {
-		log.Write("[Error] failed to render fail page. Displaying plain error message.")
+		log.ShowWrite("[Error] failed to render fail page. Displaying plain error message: %s", err.Error())
 		_, err = w.Write([]byte(message))
 		if err != nil {
-			log.Write("[Error] failed to write plain error message: %s", err.Error())
+			log.ShowWrite("[Error] failed to write plain error message: %s", err.Error())
 		}
 		return
 	}
@@ -54,6 +54,6 @@ func fail(w http.ResponseWriter, r *http.Request, status int, message string) {
 	}
 	err = tmpl.Execute(w, &errinfo)
 	if err != nil {
-		log.Write("[Error] failed to parse error info to page: %s", err.Error())
+		log.ShowWrite("[Error] failed to parse error info to page: %s", err.Error())
 	}
 }
diff --git a/internal/web/ginutils.go b/internal/web/ginutils.go
index 1cfb2da..e16a19f 100644
--- a/internal/web/ginutils.go
+++ b/internal/web/ginutils.go
@@ -114,7 +114,7 @@ func isGitRepo(path string) bool {
 // This function is a modified version of the gin-client CloneRepo method.
 func remoteCloneRepo(gincl *ginclient.Client, repopath, clonedir string, clonechan chan<- gingit.RepoFileStatus) {
 	defer close(clonechan)
-	log.ShowWrite("[Info] Starting remoteCloneRepo")
+	log.ShowWrite("[Info] starting remoteCloneRepo")
 	clonestatus := make(chan gingit.RepoFileStatus)
 	remotepath := fmt.Sprintf("%s/%s", gincl.GitAddress(), repopath)
 
@@ -438,8 +438,7 @@ func remoteAnnexGet(gitdir string, getchan chan<- gingit.RepoFileStatus, rawMode
 			err = json.Unmarshal(outline, &getresult)
 			if err != nil || getresult.Command == "" {
 				// Couldn't parse output
-				log.ShowWrite("[Warning] Could not parse 'git annex get' output")
-				log.ShowWrite(string(outline))
+				log.ShowWrite("[Warning] Could not parse 'git annex get' output: %s", string(outline))
 				// TODO: Print error at the end: Command succeeded but there was an error understanding the output
 				continue
 			}
@@ -490,7 +489,7 @@ func remoteCommitCheckout(gitdir, hash string) error {
 	cmd.Args = cmdargs
 	_, stderr, err := cmd.OutputError()
 	if err != nil {
-		log.ShowWrite("[Error] %s; %s", err.Error(), string(stderr))
+		log.ShowWrite("[Error] err: %s; stderr: %s", err.Error(), string(stderr))
 		return fmt.Errorf(string(stderr))
 	}
 	return nil
diff --git a/internal/web/hooks.go b/internal/web/hooks.go
index 5c8586b..91bd316 100644
--- a/internal/web/hooks.go
+++ b/internal/web/hooks.go
@@ -28,7 +28,7 @@ func EnableHook(w http.ResponseWriter, r *http.Request) {
 	validator := strings.ToLower(vars["validator"])
 	ut, err := getSessionOrRedirect(w, r)
 	if err != nil {
-		log.Write("[Info] %s: Redirecting to login", err.Error())
+		log.ShowWrite("[Info] %s: redirecting to login", err.Error())
 		return
 	}
 	if !helpers.SupportedValidator(validator) {
@@ -61,7 +61,7 @@ func DisableHook(w http.ResponseWriter, r *http.Request) {
 
 	ut, err := getSessionOrRedirect(w, r)
 	if err != nil {
-		log.Write("[Info] %s: Redirecting to login", err.Error())
+		log.ShowWrite("[Info] %s: redirecting to login", err.Error())
 		return
 	}
 
@@ -69,7 +69,8 @@ func DisableHook(w http.ResponseWriter, r *http.Request) {
 	err = deleteValidHook(repopath, hookid, ut)
 	if err != nil {
 		// TODO: Check if failure is for other reasons and maybe return 500 instead
-		fail(w, r, http.StatusUnauthorized, err.Error())
+		log.ShowWrite(err.Error())
+		fail(w, r, http.StatusUnauthorized, "Could not remove hook")
 		return
 	}
 	http.Redirect(w, r, fmt.Sprintf("/repos/%s/hooks", repopath), http.StatusFound)
@@ -88,7 +89,7 @@ func createValidHook(repopath string, validator string, usertoken gweb.UserToken
 	// TODO: AVOID DUPLICATES:
 	//   - If it's already hooked and we have it on record, do nothing
 	//   - If it's already hooked, but we don't know about it, check if it's valid and don't recreate
-	log.Write("Adding %s hook to %s\n", validator, repopath)
+	log.ShowWrite("[Info] adding %q hook to %q", validator, repopath)
 
 	cfg := config.Read()
 	client := ginclient.New(serveralias)
@@ -98,7 +99,7 @@ func createValidHook(repopath string, validator string, usertoken gweb.UserToken
 
 	u, err := url.Parse(cfg.Settings.RootURL)
 	if err != nil {
-		log.Write("[error] failed to parse url: %s", err.Error())
+		log.ShowWrite("[Error] failed to parse url: %s", err.Error())
 		return fmt.Errorf("hook creation failed: %s", err.Error())
 	}
 	u.Path = path.Join(u.Path, "validate", validator, repopath)
@@ -113,13 +114,13 @@ func createValidHook(repopath string, validator string, usertoken gweb.UserToken
 	}
 	res, err := client.Post(fmt.Sprintf("/api/v1/repos/%s/hooks", repopath), data)
 	if err != nil {
-		log.Write("[error] failed to post: %s", err.Error())
+		log.ShowWrite("[Error] failed to post: %s", err.Error())
 		return fmt.Errorf("hook creation failed: %s", err.Error())
 	}
 	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusCreated {
-		log.Write("[error] non-OK response: %s", res.Status)
+		log.ShowWrite("[Error] non-OK response: %s", res.Status)
 		return fmt.Errorf("hook creation failed: %s", res.Status)
 	}
 
@@ -128,23 +129,35 @@ func createValidHook(repopath string, validator string, usertoken gweb.UserToken
 }
 
 func deleteValidHook(repopath string, id int, usertoken gweb.UserToken) error {
-	log.Write("Deleting %d from %s\n", id, repopath)
+	log.ShowWrite("[Info] deleting hook %d from %q", id, repopath)
 
 	client := ginclient.New(serveralias)
 	client.UserToken = usertoken
 
 	res, err := client.Delete(fmt.Sprintf("/api/v1/repos/%s/hooks/%d", repopath, id))
 	if err != nil {
-		log.Write("[error] bad response from server %s", err.Error())
-		return err
+		return fmt.Errorf("[Error] bad response from server: %s", err.Error())
 	}
 	defer res.Body.Close()
-	log.Write("[info] removed hook for %s", repopath)
+	log.ShowWrite("[Info] removed hook for %s", repopath)
+
+	// delete repo token only if there are no more hooks registered for the current repo
+	hooks, err := getRepoHooks(client, repopath)
+	if err != nil {
+		return fmt.Errorf("[Error] checking remaining repo hooks: %s", err.Error())
+	}
+	// return without removing the repo->token link if a single active hook is found
+	log.ShowWrite("[Info] current repo hooks: %v", hooks)
+	for valname := range hooks {
+		if hooks[valname].State == hookenabled {
+			return nil
+		}
+	}
 
-	log.Write("[info] removing repository -> token link")
+	log.ShowWrite("[Info] found no active hook, removing repository -> token link")
 	err = rmTokenRepoLink(repopath)
 	if err != nil {
-		log.Write("[error] failed to delete token link: %s", err.Error())
+		log.ShowWrite("[Error] failed to delete token link: %s", err.Error())
 		// don't fail
 	}
 
diff --git a/internal/web/results.go b/internal/web/results.go
index 5e54c6c..7599096 100644
--- a/internal/web/results.go
+++ b/internal/web/results.go
@@ -120,11 +120,11 @@ func Results(w http.ResponseWriter, r *http.Request) {
 	repo := vars["repo"]
 	validator := strings.ToLower(vars["validator"])
 	if !helpers.SupportedValidator(validator) {
-		log.ShowWrite("[Error] unsupported validator '%s'\n", validator)
+		log.ShowWrite("[Error] unsupported validator '%s'", validator)
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("404 Nothing to see here...")))
 		return
 	}
-	log.ShowWrite("[Info] '%s' results for repo '%s/%s'\n", validator, user, repo)
+	log.ShowWrite("[Info] %q results for repo '%s/%s'", validator, user, repo)
 
 	srvcfg := config.Read()
 	resID, ok := vars["id"]
@@ -143,7 +143,7 @@ func Results(w http.ResponseWriter, r *http.Request) {
 	fp := filepath.Join(resdir, srvcfg.Label.ResultsBadge)
 	badge, err := ioutil.ReadFile(fp)
 	if err != nil {
-		log.ShowWrite("[Error] serving '%s/%s' badge: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] serving '%s/%s' badge: %s", user, repo, err.Error())
 	}
 
 	fp = filepath.Join(resdir, srvcfg.Label.ResultsFile)
@@ -176,13 +176,13 @@ func notValidatedYet(w http.ResponseWriter, r *http.Request, badge []byte, valid
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.NotValidatedYet)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -213,7 +213,7 @@ func notValidatedYet(w http.ResponseWriter, r *http.Request, badge []byte, valid
 
 	err = tmpl.ExecuteTemplate(w, "layout", info)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -223,13 +223,13 @@ func renderInProgress(w http.ResponseWriter, r *http.Request, badge []byte, vali
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.GenericResults)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -252,7 +252,7 @@ func renderInProgress(w http.ResponseWriter, r *http.Request, badge []byte, vali
 
 	err = tmpl.ExecuteTemplate(w, "layout", info)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -278,7 +278,7 @@ func resultsHistory(validator, user, repo string) ResultsHistoryStruct {
 	resdir := filepath.Join(srvcfg.Dir.Result, validator, user, repo)
 	fileinfos, err := myReadDir(resdir)
 	if err != nil {
-		log.ShowWrite("[Error] cannot retrieve results history '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] cannot retrieve results history '%s/%s' result: %s", user, repo, err.Error())
 		return ret
 	}
 	for _, i := range fileinfos {
@@ -292,7 +292,7 @@ func resultsHistory(validator, user, repo string) ResultsHistoryStruct {
 			var res Result
 			res.Href = pth
 			res.Alt = i.Name()
-			res.Text1 = i.ModTime().Format("2006-01-02")
+			res.Text1 = i.ModTime().UTC().Format("2006-01-02")
 			res.Text2 = i.ModTime().Format("15:04:05")
 			res.Badge = template.HTML(badge)
 			ret.Results = append(ret.Results, res)
@@ -307,7 +307,7 @@ func renderBIDSResults(w http.ResponseWriter, r *http.Request, badge []byte, con
 	err := json.Unmarshal(content, &resBIDS)
 	errMsg := ""
 	if err != nil {
-		log.ShowWrite("[Error] unmarshalling '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] unmarshalling '%s/%s' result: %s", user, repo, err.Error())
 		errMsg = "Could not validate format as BIDS."
 	}
 
@@ -315,13 +315,13 @@ func renderBIDSResults(w http.ResponseWriter, r *http.Request, badge []byte, con
 	tmpl := template.New("layout")
 	tmpl, err = tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.BidsResults)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -345,7 +345,7 @@ func renderBIDSResults(w http.ResponseWriter, r *http.Request, badge []byte, con
 
 	err = tmpl.ExecuteTemplate(w, "layout", info)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -357,13 +357,13 @@ func renderNIXResults(w http.ResponseWriter, r *http.Request, badge []byte, cont
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.GenericResults)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -386,7 +386,7 @@ func renderNIXResults(w http.ResponseWriter, r *http.Request, badge []byte, cont
 
 	err = tmpl.ExecuteTemplate(w, "layout", info)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -398,13 +398,13 @@ func renderODMLResults(w http.ResponseWriter, r *http.Request, badge []byte, con
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.GenericResults)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
@@ -427,7 +427,7 @@ func renderODMLResults(w http.ResponseWriter, r *http.Request, badge []byte, con
 
 	err = tmpl.ExecuteTemplate(w, "layout", info)
 	if err != nil {
-		log.ShowWrite("[Error] '%s/%s' result: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] '%s/%s' result: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("500 Something went wrong...")))
 		return
 	}
diff --git a/internal/web/status.go b/internal/web/status.go
index da6b311..74381f8 100644
--- a/internal/web/status.go
+++ b/internal/web/status.go
@@ -19,20 +19,20 @@ import (
 func Status(w http.ResponseWriter, r *http.Request) {
 	validator := mux.Vars(r)["validator"]
 	if !helpers.SupportedValidator(validator) {
-		log.Write("[Error] unsupported validator '%s'\n", validator)
+		log.ShowWrite("[Error] unsupported validator %q", validator)
 		http.ServeContent(w, r, "unavailable", time.Now(), bytes.NewReader([]byte("404 Nothing to see here...")))
 		return
 	}
 	user := mux.Vars(r)["user"]
 	repo := mux.Vars(r)["repo"]
-	log.Write("[Info] '%s' status for repo '%s/%s'\n", validator, user, repo)
+	log.ShowWrite("[Info] %q status for repo '%s/%s'", validator, user, repo)
 
 	srvcfg := config.Read()
 
 	fp := filepath.Join(srvcfg.Dir.Result, "bids", user, repo, srvcfg.Label.ResultsFolder, srvcfg.Label.ResultsBadge)
 	content, err := ioutil.ReadFile(fp)
 	if err != nil {
-		log.Write("[Error] serving '%s/%s' status: %s\n", user, repo, err.Error())
+		log.ShowWrite("[Error] serving '%s/%s' status: %s", user, repo, err.Error())
 		http.ServeContent(w, r, "unavailable.svg", time.Now(), bytes.NewReader([]byte(resources.UnavailableBadge)))
 		return
 	}
diff --git a/internal/web/token.go b/internal/web/token.go
index 79f95a1..6bc6a66 100644
--- a/internal/web/token.go
+++ b/internal/web/token.go
@@ -40,7 +40,7 @@ func loadToken(path string) (gweb.UserToken, error) {
 	ut := gweb.UserToken{}
 	tokenfile, err := os.Open(path)
 	if err != nil {
-		log.Write("[Error] Failed to load token from %s", path)
+		log.ShowWrite("[Error] failed to load token from %s: %s", path, err.Error())
 		return ut, err
 	}
 	defer tokenfile.Close()
@@ -60,7 +60,7 @@ func linkToSession(username string, sessionid string) error {
 	// this will also fix outdated tokens. Log any error but try to continue.
 	err := os.Remove(sidfile)
 	if err != nil {
-		log.Write("[Error] removing session link: %s", err.Error())
+		log.ShowWrite("[Error] removing session link: %s", err.Error())
 	}
 	return os.Symlink(utfile, sidfile)
 }
@@ -86,7 +86,7 @@ func linkToRepo(username string, repopath string) error {
 	// this will also fix outdated tokens Log any error but try to continue.
 	err := os.Remove(sidfile)
 	if err != nil {
-		log.Write("[Error] removing session link: %s", err.Error())
+		log.ShowWrite("[Error] removing session link: %s", err.Error())
 	}
 	return os.Symlink(utfile, sidfile)
 }
diff --git a/internal/web/user.go b/internal/web/user.go
index 067037a..5db279e 100644
--- a/internal/web/user.go
+++ b/internal/web/user.go
@@ -70,7 +70,7 @@ func makeSessionKey(gcl *ginclient.Client, keyname string) error {
 
 	configpath, err := gcfg.Path(true)
 	if err != nil {
-		log.Write("Could not create config directory for private key")
+		log.ShowWrite("[Error] could not create config directory for private key: %s", err.Error())
 		return err
 	}
 	keyfilepath := filepath.Join(configpath, fmt.Sprintf("%s.key", keyname))
@@ -99,7 +99,7 @@ func generateNewSessionID() (string, error) {
 	if _, err := io.ReadFull(rand.Reader, id); err != nil {
 		// This will bubble up and result in an authentication failure. Is
 		// there a better message to display to the user? Perhaps 500?
-		log.Write("[error] Failed to generate random session ID")
+		log.ShowWrite("[Error] failed to generate random session ID: %s", err.Error())
 		return "", err
 	}
 	return base64.StdEncoding.EncodeToString(id), nil
@@ -117,33 +117,33 @@ func doLogin(username, password string) (string, error) {
 	clientID := cfg.Settings.ClientID
 
 	// retrieve user's active tokens
-	log.Write("Retrieving tokens for user '%s'", username)
+	log.ShowWrite("[Info] retrieving tokens for user %q", username)
 	tokens, err := gincl.GetTokens(username, password)
 	if err != nil {
 		return "", err
 	}
 
 	// check if we have a gin-valid token
-	log.Write("Checking for existing token")
+	log.ShowWrite("[Info] checking for existing token")
 	for _, token := range tokens {
 		if token.Name == clientID {
 			// found our token
 			gincl.UserToken.Username = username
 			gincl.UserToken.Token = token.Sha1
-			log.Write("Found %s access token", clientID)
+			log.ShowWrite("[Info] found access token %s", clientID)
 			break
 		}
 	}
 
 	if len(gincl.UserToken.Token) == 0 {
 		// no existing token; creating new one
-		log.Write("Requesting new token from server")
+		log.ShowWrite("[Info] requesting new token from server")
 		glog.Write("Performing login from gin-valid")
 		err = gincl.NewToken(username, password, clientID)
 		if err != nil {
 			return "", err
 		}
-		log.Write("Login successful. Username: %s", username)
+		log.ShowWrite("[Info] login successful. Username: %s", username)
 	}
 
 	err = saveToken(gincl.UserToken)
@@ -168,17 +168,17 @@ func LoginGet(w http.ResponseWriter, r *http.Request) {
 
 // loginForm renders the login form
 func loginForm(w http.ResponseWriter, r *http.Request, errMsg string) {
-	log.Write("Login page")
+	log.ShowWrite("[Info] login form page")
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.Write("[Error] failed to parse html layout page")
+		log.ShowWrite("[Error] failed to parse html layout page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.Login)
 	if err != nil {
-		log.Write("[Error] failed to render login page")
+		log.ShowWrite("[Error] failed to render login page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
@@ -205,7 +205,7 @@ func loginForm(w http.ResponseWriter, r *http.Request, errMsg string) {
 
 // LoginPost logs in the user to the GIN server, storing a session token.
 func LoginPost(w http.ResponseWriter, r *http.Request) {
-	log.ShowWrite("Handling user login")
+	log.ShowWrite("[Info] handling user login")
 	err := r.ParseForm()
 	if err != nil {
 		log.ShowWrite("[Error] could not parse request form data: %s", err.Error())
@@ -216,13 +216,13 @@ func LoginPost(w http.ResponseWriter, r *http.Request) {
 	username := r.FormValue("username")
 	password := r.FormValue("password")
 	if username == "" || password == "" {
-		log.Write("[error] Invalid form data")
+		log.ShowWrite("[Error] missing login form data")
 		loginForm(w, r, "Authentication failed")
 		return
 	}
 	sessionid, err := doLogin(username, password)
 	if err != nil {
-		log.Write("[error] Login failed: %s", err.Error())
+		log.ShowWrite("[Error] login failed: %s", err.Error())
 		loginForm(w, r, "Authentication failed")
 		return
 	}
@@ -275,7 +275,7 @@ func getSessionOrRedirect(w http.ResponseWriter, r *http.Request) (gweb.UserToke
 	usertoken, err := getTokenBySession(cookie.Value)
 	if err != nil {
 		http.Redirect(w, r, "/login", http.StatusFound)
-		log.Write("[Error] Loading token failed: %s", err.Error())
+		log.ShowWrite("[Error] loading token failed: %s", err.Error())
 		return gweb.UserToken{}, fmt.Errorf("invalid session found in cookie")
 	}
 	return usertoken, nil
@@ -287,7 +287,7 @@ func getSessionOrRedirect(w http.ResponseWriter, r *http.Request) (gweb.UserToke
 func ListRepos(w http.ResponseWriter, r *http.Request) {
 	ut, err := getSessionOrRedirect(w, r)
 	if err != nil {
-		log.Write("[Info] %s: Redirecting to login", err.Error())
+		log.ShowWrite("[Info] %s: redirecting to login", err.Error())
 		return
 	}
 
@@ -313,7 +313,7 @@ func ListRepos(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	fmt.Printf("Got %d repos\n", len(userrepos))
+	log.ShowWrite("[Info] found %d repositories", len(userrepos))
 	tmpl := template.New("layout")
 	funcmap := map[string]interface{}{
 		"ToLower": strings.ToLower,
@@ -322,13 +322,13 @@ func ListRepos(w http.ResponseWriter, r *http.Request) {
 	tmpl.Funcs(funcmap)
 	tmpl, err = tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.Write("[Error] failed to parse html layout page")
+		log.ShowWrite("[Error] failed to parse html layout page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.RepoList)
 	if err != nil {
-		log.Write("[Error] failed to render repository list page: %s", err.Error())
+		log.ShowWrite("[Error] failed to render repository list page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
@@ -393,7 +393,7 @@ func matchValidator(path string) (string, error) {
 	validator := match[1]
 
 	if !helpers.SupportedValidator(validator) {
-		return "", fmt.Errorf("URL matches pattern but validator '%s' is not known", validator)
+		return "", fmt.Errorf("URL matches pattern but validator %q is not known", validator)
 	}
 
 	return validator, nil
@@ -406,12 +406,12 @@ func getRepoHooks(cl *ginclient.Client, repopath string) (map[string]ginhook, er
 	res, err := cl.Get(path.Join("api", "v1", "repos", repopath, "hooks"))
 	if err != nil {
 		// Bad request?
-		log.Write("hook request failed for %s", repopath)
+		log.ShowWrite("[Error] hook request failed for %s: %s", repopath, err.Error())
 		return nil, fmt.Errorf("hook request failed")
 	}
 	if res.StatusCode != http.StatusOK {
 		// Bad repo path? Unauthorised request?
-		log.Write("hook request for %s returned non-OK exit status: %s", repopath, res.Status)
+		log.ShowWrite("[Error] hook request for %s returned non-OK exit status: %s", repopath, res.Status)
 		return nil, fmt.Errorf("hook request returned non-OK exit status: %s", res.Status)
 	}
 	var gogshooks []gogs.Hook
@@ -419,13 +419,13 @@ func getRepoHooks(cl *ginclient.Client, repopath string) (map[string]ginhook, er
 	b, err := ioutil.ReadAll(res.Body)
 	if err != nil {
 		// failed to read response body
-		log.Write("failed to read response for %s", repopath)
+		log.ShowWrite("[Error] failed to read response for %s: %s", repopath, err.Error())
 		return nil, fmt.Errorf("failed to read response")
 	}
 	err = json.Unmarshal(b, &gogshooks)
 	if err != nil {
 		// failed to parse response body
-		log.Write("failed to parse hooks list for %s", repopath)
+		log.ShowWrite("[Error] failed to parse hooks list for %s: %s", repopath, err.Error())
 		return nil, fmt.Errorf("failed to parse hooks list")
 	}
 
@@ -435,16 +435,16 @@ func getRepoHooks(cl *ginclient.Client, repopath string) (map[string]ginhook, er
 		hookurl, err := url.Parse(hook.Config["url"])
 		if err != nil {
 			// can't parse URL. Ignore
-			log.Write("can't parse URL %s", hook.Config["url"])
+			log.ShowWrite("[Error] can't parse URL %s: %s", hook.Config["url"], err.Error())
 			continue
 		}
 		validator, err := matchValidator(hookurl.Path)
 		if err != nil {
 			// Validator not recognised (either path was bad or validator is
 			// not supported). Either way, just continue.
-			log.Write("validator in path not recognised %s (%s)", hookurl.String(), hookurl.Path)
-			log.Write("hook URL in config: %s", hook.Config["url"])
-			log.Write(err.Error())
+			log.ShowWrite("[Error] validator in path not recognised %s (%s)", hookurl.String(), hookurl.Path)
+			log.ShowWrite("[Error] hook URL in config: %s", hook.Config["url"])
+			log.ShowWrite("[Error] %s", err.Error())
 			continue
 		}
 		// Check if Active, and 'push' is in Events
@@ -457,10 +457,10 @@ func getRepoHooks(cl *ginclient.Client, repopath string) (map[string]ginhook, er
 		}
 		var state hookstate
 		if hook.Active && pushenabled {
-			log.Write("found %s hook for %s", validator, repopath)
+			log.ShowWrite("[Info] found %s hook for %s", validator, repopath)
 			state = hookenabled
 		} else {
-			log.Write("found disabled or invalid %s hook for %s", validator, repopath)
+			log.ShowWrite("[Info] found disabled or invalid %s hook for %s", validator, repopath)
 			state = hookdisabled
 		}
 		hooks[validator] = ginhook{validator, hook.ID, state}
@@ -481,7 +481,7 @@ func getRepoHooks(cl *ginclient.Client, repopath string) (map[string]ginhook, er
 func ShowRepo(w http.ResponseWriter, r *http.Request) {
 	ut, err := getSessionOrRedirect(w, r)
 	if err != nil {
-		log.Write("[Info] %s: Redirecting to login", err.Error())
+		log.ShowWrite("[Info] %s: redirecting to login", err.Error())
 		return
 	}
 
@@ -491,14 +491,11 @@ func ShowRepo(w http.ResponseWriter, r *http.Request) {
 	repopath := fmt.Sprintf("%s/%s", user, repo)
 	cl := ginclient.New(serveralias)
 	cl.UserToken = ut
-	fmt.Printf("Requesting repository info %s\n", repopath)
-	fmt.Printf("Server alias: %s\n", serveralias)
-	fmt.Println("Server configuration:")
-	fmt.Println(cl.Host)
+	log.ShowWrite("[Info] server alias %q at %q; repo %q", serveralias, cl.Host, repopath)
 
 	repoinfo, err := cl.GetRepo(repopath)
 	if err != nil {
-		log.ShowWrite("[Error] Repo info failed: %s", err.Error())
+		log.ShowWrite("[Error] repo info failed: %s", err.Error())
 		w.WriteHeader(http.StatusNotFound)
 		_, err = w.Write([]byte("not found"))
 		if err != nil {
@@ -515,13 +512,13 @@ func ShowRepo(w http.ResponseWriter, r *http.Request) {
 	tmpl.Funcs(funcmap)
 	tmpl, err = tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.Write("[Error] failed to parse html layout page")
+		log.ShowWrite("[Error] failed to parse html layout page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
 	tmpl, err = tmpl.Parse(templates.RepoPage)
 	if err != nil {
-		log.Write("[Error] failed to render repository page: %s", err.Error())
+		log.ShowWrite("[Error] failed to render repository page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
diff --git a/internal/web/validate.go b/internal/web/validate.go
index c3097ae..ba39471 100644
--- a/internal/web/validate.go
+++ b/internal/web/validate.go
@@ -82,14 +82,14 @@ func validateBIDS(valroot, resdir string) error {
 	var validateNifti bool
 
 	cfgpath := filepath.Join(valroot, srvcfg.Label.ValidationConfigFile)
-	log.ShowWrite("[Info] looking for config file at '%s'", cfgpath)
+	log.ShowWrite("[Info] looking for config file at %q", cfgpath)
 	if fi, err := os.Stat(cfgpath); err == nil && !fi.IsDir() {
 		valcfg, err := handleValidationConfig(cfgpath)
 		if err == nil {
 			checkdir := filepath.Join(valroot, valcfg.Bidscfg.BidsRoot)
 			if fi, err = os.Stat(checkdir); err == nil && fi.IsDir() {
 				valroot = checkdir
-				log.ShowWrite("[Info] using validation root directory: %s\n%s", valroot, checkdir)
+				log.ShowWrite("[Info] using validation root directory: %s; %s", valroot, checkdir)
 			} else {
 				log.ShowWrite("[Error] reading validation root directory: %s", err.Error())
 			}
@@ -98,12 +98,12 @@ func validateBIDS(valroot, resdir string) error {
 			log.ShowWrite("[Error] unmarshalling validation config file: %s", err.Error())
 		}
 	} else {
-		log.ShowWrite("[Info] no validation config file found or processed, running from repo root (%s)", err.Error())
+		log.ShowWrite("[Info] no validation config file found or processed, running from repo root: %s", err.Error())
 	}
 
 	// Ignoring NiftiHeaders for now, since it seems to be a common error
 	outBadge := filepath.Join(resdir, srvcfg.Label.ResultsBadge)
-	log.ShowWrite("[Info] Running bids validation: '%s %t --json %s'", srvcfg.Exec.BIDS, validateNifti, valroot)
+	log.ShowWrite("[Info] running bids validation: '%s %t --json %s'", srvcfg.Exec.BIDS, validateNifti, valroot)
 
 	// Make sure the validator arguments are in the right order
 	var args []string
@@ -122,7 +122,7 @@ func validateBIDS(valroot, resdir string) error {
 	cmd.Stderr = &serr
 	// cmd.Dir = tmpdir
 	if err := cmd.Run(); err != nil {
-		err = fmt.Errorf("[Error] running bids validation (%s): '%s', '%s'", valroot, err.Error(), serr.String())
+		err = fmt.Errorf("[Error] running bids validation (%s): %q, %q", valroot, err.Error(), serr.String())
 		log.ShowWrite(err.Error())
 		return err
 	}
@@ -217,7 +217,7 @@ func validateNIX(valroot, resdir string) error {
 	cmd.Stderr = &serr
 	// cmd.Dir = tmpdir
 	if err = cmd.Run(); err != nil {
-		err = fmt.Errorf("[Error] running NIX validation (%s): '%s', '%s'", valroot, err.Error(), serr.String())
+		err = fmt.Errorf("[Error] running NIX validation (%s): %q, %q", valroot, err.Error(), serr.String())
 		log.ShowWrite(err.Error())
 		return err
 	}
@@ -345,7 +345,7 @@ func validateODML(valroot, resdir string) error {
 func runValidatorBoth(validator, repopath, commit, commitname string, gcl *ginclient.Client, automatic bool) string {
 	respath := filepath.Join(validator, repopath, commit)
 	go func() {
-		log.ShowWrite("[Info] Running %s validation on repository %q (%s)", validator, repopath, commitname)
+		log.ShowWrite("[Info] running %s validation on repository %q (%s)", validator, repopath, commitname)
 
 		// TODO add check if a repo is currently being validated. Since the cloning
 		// can potentially take quite some time prohibit running the same
@@ -369,7 +369,7 @@ func runValidatorBoth(validator, repopath, commit, commitname string, gcl *gincl
 
 		tmpdir, err := ioutil.TempDir(srvcfg.Dir.Temp, validator)
 		if err != nil {
-			log.ShowWrite("[Error] Internal error: Couldn't create temporary gin directory: %s", err.Error())
+			log.ShowWrite("[Error] could not create temporary gin directory: %s", err.Error())
 			writeValFailure(resdir)
 			return
 		}
@@ -487,7 +487,7 @@ func cloneAndGet(gcl *ginclient.Client, tmpdir, commit, repopath string, checkou
 	repoDir := filepath.Join(tmpdir, repoName)
 	remoteGitDir, err := filepath.Abs(repoDir)
 	if err != nil {
-		return fmt.Errorf("[Error] getting absolute path for %q", repoDir)
+		return fmt.Errorf("[Error] getting absolute path for %q: %s", repoDir, err.Error())
 	}
 
 	if checkoutCommit {
@@ -497,7 +497,7 @@ func cloneAndGet(gcl *ginclient.Client, tmpdir, commit, repopath string, checkou
 			return fmt.Errorf("[Error] failed to checkout commit %q: %s", commit, err.Error())
 		}
 	}
-	log.ShowWrite("[Info] Downloading content")
+	log.ShowWrite("[Info] downloading content")
 	getcontentchan := make(chan git.RepoFileStatus)
 	// TODO: Get only the content for the files that will be validated
 	// do not format annex output as json
@@ -565,7 +565,7 @@ func renderValidationForm(w http.ResponseWriter, r *http.Request, errMsg string)
 	tmpl := template.New("layout")
 	tmpl, err := tmpl.Parse(templates.Layout)
 	if err != nil {
-		log.ShowWrite("[Error] failed to parse html layout page")
+		log.ShowWrite("[Error] failed to parse html layout page: %s", err.Error())
 		fail(w, r, http.StatusInternalServerError, "something went wrong")
 		return
 	}
@@ -617,12 +617,12 @@ func PubValidatePost(w http.ResponseWriter, r *http.Request) {
 	}
 	validator := r.Form["validator"][0]
 
-	log.ShowWrite("[Info] About to validate repository '%s' with %s", repopath, ginuser)
-	log.ShowWrite("[Info] Logging in to GIN server")
+	log.ShowWrite("[Info] validating repository %q with user %s", repopath, ginuser)
+	log.ShowWrite("[Info] logging into GIN server")
 	gcl := ginclient.New(serveralias)
 	err = gcl.Login(ginuser, srvcfg.Settings.GINPassword, srvcfg.Settings.ClientID)
 	if err != nil {
-		log.ShowWrite("[Error] failed to login as %s", ginuser)
+		log.ShowWrite("[Error] failed to login as %s: %s", ginuser, err.Error())
 		msg := fmt.Sprintf("failed to validate '%s': %s", repopath, err.Error())
 		fail(w, r, http.StatusUnauthorized, msg)
 		return
@@ -652,7 +652,7 @@ func PubValidatePost(w http.ResponseWriter, r *http.Request) {
 // repository is a valid BIDS dataset.
 // Any cloned files are cleaned up after the check is done.
 func Validate(w http.ResponseWriter, r *http.Request) {
-	log.ShowWrite("[Info] Entering validation")
+	log.ShowWrite("[Info] starting validation")
 	// TODO: Simplify/split this function
 	secret := r.Header.Get("X-Gogs-Signature")
 
@@ -687,14 +687,14 @@ func Validate(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	validator := vars["validator"]
 	if !helpers.SupportedValidator(validator) {
-		log.ShowWrite("[Error] unsupported validator (%v)", validator)
+		log.ShowWrite("[Error] unsupported validator %q", validator)
 		fail(w, r, http.StatusNotFound, "unsupported validator")
 		return
 	}
 	user := vars["user"]
 	repo := vars["repo"]
 	repopath := fmt.Sprintf("%s/%s", user, repo)
-	log.ShowWrite("[Info] '%s' validation for repo '%s'", validator, repopath)
+	log.ShowWrite("[Info] %q validation for repo %q", validator, repopath)
 
 	// TODO add check if a repo is currently being validated. Since the cloning
 	// can potentially take quite some time prohibit running the same
@@ -710,12 +710,12 @@ func Validate(w http.ResponseWriter, r *http.Request) {
 	ut, err := getTokenByRepo(repopath)
 	if err != nil {
 		// We don't have a valid token for this repository: can't clone
-		log.ShowWrite("[Error] Bad Token: %v", err)
+		log.ShowWrite("[Error] bad token: %s", err.Error())
 		msg := fmt.Sprintf("accessing '%s': no access token found", repopath)
 		fail(w, r, http.StatusUnauthorized, msg)
 		return
 	}
-	log.ShowWrite("[Info] Using user %s", ut.Username)
+	log.ShowWrite("[Info] using user %s", ut.Username)
 	gcl := ginclient.New(serveralias)
 	gcl.UserToken = ut
 
@@ -726,7 +726,7 @@ func Validate(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	log.ShowWrite("[Info] Got user %s. Checking repo", gcl.Username)
+	log.ShowWrite("[Info] got user %s; checking repo", gcl.Username)
 	// Payload is good. Run validator asynchronously and return OK header
 	runValidator(validator, repopath, commithash, gcl)