diff --git a/bin/quickstart.sh b/bin/quickstart.sh
index ed3ba9ab..aea348a0 100755
--- a/bin/quickstart.sh
+++ b/bin/quickstart.sh
@@ -1,104 +1,104 @@
 #!/bin/bash
 
 set -e
 
 function die() {
     echo "$1"
     exit 1
 }
 
 rpm -qv composer >/dev/null 2>&1 || \
     test ! -z "$(which composer 2>/dev/null)" || \
     die "Is composer installed?"
 
 rpm -qv docker-compose >/dev/null 2>&1 || \
     test ! -z "$(which docker-compose 2>/dev/null)" || \
     die "Is docker-compose installed?"
 
 rpm -qv npm >/dev/null 2>&1 || \
     test ! -z "$(which npm 2>/dev/null)" || \
     die "Is npm installed?"
 
 rpm -qv php >/dev/null 2>&1 || \
     test ! -z "$(which php 2>/dev/null)" || \
     die "Is php installed?"
 
 rpm -qv php-ldap >/dev/null 2>&1 || \
     test ! -z "$(php --ini | grep ldap)" || \
     die "Is php-ldap installed?"
 
 rpm -qv php-mysqlnd >/dev/null 2>&1 || \
     test ! -z "$(php --ini | grep mysql)" || \
     die "Is php-mysqlnd installed?"
 
 test ! -z "$(php --modules | grep swoole)" || \
     die "Is swoole installed?"
 
 test ! -z "$(grep 'systemd.unified_cgroup_hierarchy=0' /proc/cmdline)" || \
     die "systemd containers only work with cgroupv1 (use 'grubby --update-kernel=ALL --args=\"systemd.unified_cgroup_hierarchy=0\"' and a reboot to fix)"
 
 base_dir=$(dirname $(dirname $0))
 
 # Always reset .env with .env.example
 cp src/.env.example src/.env
 
 if [ -f "src/.env.local.example" ]; then
     # Ensure there's a line ending
     echo "" >> src/.env
     cat src/.env.local.example >> src/.env
 fi
 
 docker pull docker.io/kolab/centos7:latest
 
 docker-compose down --remove-orphans
 docker-compose build coturn kolab mariadb openvidu kurento-media-server pdns-sql proxy redis nginx
 
 bin/regen-certs
 
 docker-compose up -d coturn kolab mariadb openvidu kurento-media-server pdns-sql proxy redis
 
 pushd ${base_dir}/src/
 
 rm -rf vendor/ composer.lock
 php -dmemory_limit=-1 $(which composer) install
 npm install
 find bootstrap/cache/ -type f ! -name ".gitignore" -delete
 ./artisan key:generate
 ./artisan clear-compiled
 ./artisan cache:clear
 ./artisan horizon:install
 
 if [ ! -f storage/oauth-public.key -o ! -f storage/oauth-private.key ]; then
     ./artisan passport:keys --force
 fi
 
 cat >> .env << EOF
 PASSPORT_PRIVATE_KEY="$(cat storage/oauth-private.key)"
 PASSPORT_PUBLIC_KEY="$(cat storage/oauth-public.key)"
 EOF
 
 
 if rpm -qv chromium 2>/dev/null; then
     chver=$(rpmquery --queryformat="%{VERSION}" chromium | awk -F'.' '{print $1}')
     ./artisan dusk:chrome-driver ${chver}
 fi
 
 if [ ! -f 'resources/countries.php' ]; then
     ./artisan data:countries
 fi
 
 npm run dev
 popd
 
 docker-compose up -d nginx
 
 pushd ${base_dir}/src/
 rm -rf database/database.sqlite
 ./artisan db:ping --wait
 php -dmemory_limit=512M ./artisan migrate:refresh --seed
 ./artisan data:import || :
 ./artisan octane:stop >/dev/null 2>&1 || :
-OCTANE_DAEMONIZE=true ./artisan octane:start --host=$(grep OCTANE_HTTP_HOST .env | tail -n1 | sed "s/OCTANE_HTTP_HOST=//")
+nohup ./artisan octane:start --host=$(grep OCTANE_HTTP_HOST .env | tail -n1 | sed "s/OCTANE_HTTP_HOST=//") > octane.out &
 ./artisan horizon:terminate >/dev/null 2>&1 || :
-nohup ./artisan horizon >/dev/null 2>&1 &
+nohup ./artisan horizon > horizon.out &
 popd
diff --git a/src/config/octane.php b/src/config/octane.php
index 514a6296..b89f15b5 100644
--- a/src/config/octane.php
+++ b/src/config/octane.php
@@ -1,245 +1,246 @@
 <?php
 
 use Laravel\Octane\Contracts\OperationTerminated;
 use Laravel\Octane\Events\RequestHandled;
 use Laravel\Octane\Events\RequestReceived;
 use Laravel\Octane\Events\RequestTerminated;
 use Laravel\Octane\Events\TaskReceived;
 use Laravel\Octane\Events\TaskTerminated;
 use Laravel\Octane\Events\TickReceived;
 use Laravel\Octane\Events\TickTerminated;
 use Laravel\Octane\Events\WorkerErrorOccurred;
 use Laravel\Octane\Events\WorkerStarting;
 use Laravel\Octane\Events\WorkerStopping;
 use Laravel\Octane\Listeners\CollectGarbage;
 use Laravel\Octane\Listeners\DisconnectFromDatabases;
 use Laravel\Octane\Listeners\EnsureUploadedFilesAreValid;
 use Laravel\Octane\Listeners\EnsureUploadedFilesCanBeMoved;
 use Laravel\Octane\Listeners\FlushTemporaryContainerInstances;
 use Laravel\Octane\Listeners\FlushUploadedFiles;
 use Laravel\Octane\Listeners\ReportException;
 use Laravel\Octane\Listeners\StopWorkerIfNecessary;
 use Laravel\Octane\Octane;
 
 return [
 
     /*
     |--------------------------------------------------------------------------
     | Octane Server
     |--------------------------------------------------------------------------
     |
     | This value determines the default "server" that will be used by Octane
     | when starting, restarting, or stopping your server via the CLI. You
     | are free to change this to the supported server of your choosing.
     |
     | Supported: "roadrunner", "swoole"
     |
     */
 
     'server' => env('OCTANE_SERVER', 'swoole'),
 
     /*
     |--------------------------------------------------------------------------
     | Force HTTPS
     |--------------------------------------------------------------------------
     |
     | When this configuration value is set to "true", Octane will inform the
     | framework that all absolute links must be generated using the HTTPS
     | protocol. Otherwise your links may be generated using plain HTTP.
     |
     */
 
     'https' => env('OCTANE_HTTPS', true),
 
     /*
     |--------------------------------------------------------------------------
     | Octane Listeners
     |--------------------------------------------------------------------------
     |
     | All of the event listeners for Octane's events are defined below. These
     | listeners are responsible for resetting your application's state for
     | the next request. You may even add your own listeners to the list.
     |
     */
 
     'listeners' => [
         WorkerStarting::class => [
             EnsureUploadedFilesAreValid::class,
             EnsureUploadedFilesCanBeMoved::class,
         ],
 
         RequestReceived::class => [
             ...Octane::prepareApplicationForNextOperation(),
             ...Octane::prepareApplicationForNextRequest(),
             //
         ],
 
         RequestHandled::class => [
             //
         ],
 
         RequestTerminated::class => [
             // FlushUploadedFiles::class,
         ],
 
         TaskReceived::class => [
             ...Octane::prepareApplicationForNextOperation(),
             //
         ],
 
         TaskTerminated::class => [
             //
         ],
 
         TickReceived::class => [
             ...Octane::prepareApplicationForNextOperation(),
             //
         ],
 
         TickTerminated::class => [
             //
         ],
 
         OperationTerminated::class => [
             FlushTemporaryContainerInstances::class,
             // DisconnectFromDatabases::class,
             CollectGarbage::class,
         ],
 
         WorkerErrorOccurred::class => [
             ReportException::class,
             StopWorkerIfNecessary::class,
         ],
 
         WorkerStopping::class => [
             //
         ],
     ],
 
     /*
     |--------------------------------------------------------------------------
     | Warm / Flush Bindings
     |--------------------------------------------------------------------------
     |
     | The bindings listed below will either be pre-warmed when a worker boots
     | or they will be flushed before every new request. Flushing a binding
     | will force the container to resolve that binding again when asked.
     |
     */
 
     'warm' => [
         ...Octane::defaultServicesToWarm(),
     ],
 
     'flush' => [
     ],
 
     /*
     |--------------------------------------------------------------------------
     | Octane Cache Table
     |--------------------------------------------------------------------------
     |
     | While using Swoole, you may leverage the Octane cache, which is powered
     | by a Swoole table. You may set the maximum number of rows as well as
     | the number of bytes per row using the configuration options below.
     |
     */
 
     'cache' => [
         'rows' => 1000,
         'bytes' => 10000,
     ],
 
     /*
     |--------------------------------------------------------------------------
     | Octane Swoole Tables
     |--------------------------------------------------------------------------
     |
     | While using Swoole, you may define additional tables as required by the
     | application. These tables can be used to store data that needs to be
     | quickly accessed by other workers on the particular Swoole server.
     |
     */
 
     'tables' => [
 /*
         'example:1000' => [
             'name' => 'string:1000',
             'votes' => 'int',
         ],
 */
     ],
 
     /*
     |--------------------------------------------------------------------------
     | File Watching
     |--------------------------------------------------------------------------
     |
     | The following list of files and directories will be watched when using
     | the --watch option offered by Octane. If any of the directories and
     | files are changed, Octane will automatically reload your workers.
     |
     */
 
     'watch' => [
         'app',
         'bootstrap',
         'config',
         'database',
         'public/**/*.php',
         'resources/**/*.php',
         'routes',
         'composer.lock',
         '.env',
     ],
 
     /*
     |--------------------------------------------------------------------------
     | Garbage Collection Threshold
     |--------------------------------------------------------------------------
     |
     | When executing long-lived PHP scripts such as Octane, memory can build
     | up before being cleared by PHP. You can force Octane to run garbage
     | collection if your application consumes this amount of megabytes.
     |
     */
 
     'garbage' => 64,
 
     /*
     |--------------------------------------------------------------------------
     | Maximum Execution Time
     |--------------------------------------------------------------------------
     |
     | The following setting configures the maximum execution time for requests
     | being handled by Octane. You may set this value to 0 to indicate that
     | there isn't a specific time limit on Octane request execution time.
     |
     */
 
     'max_execution_time' => 30,
 
     /*
     |--------------------------------------------------------------------------
     | Swoole configuration
     |--------------------------------------------------------------------------
     |
     | See Laravel\Octane\Command\StartSwooleCommand
     */
 
     'swoole' => [
         'options' => [
             'log_file' => storage_path('logs/swoole_http.log'),
             'package_max_length' => 10 * 1024 * 1024,
             'enable_coroutine' => false,
-            'daemonize' => env('OCTANE_DAEMONIZE', false),
+            //FIXME the daemonize option does not work
+            // 'daemonize' => env('OCTANE_DAEMONIZE', true),
             //FIXME accessing app()->environment in here renders artisan disfunctional. I suppose it's too early.
             //'log_level' => app()->environment('local') ? SWOOLE_LOG_INFO : SWOOLE_LOG_ERROR,
             // 'reactor_num' => , // number of available cpus by default
             'send_yield' => true,
             'socket_buffer_size' => 10 * 1024 * 1024,
             // 'task_worker_num' => // number of available cpus by default
             // 'worker_num' => // number of available cpus by default
         ],
     ],
 ];