
<p class="has-drop-cap">1 En av kullens främsta fyraåringar mot äldre, betydligt mer rutinerade konkurrenter. Jan-Olov Persson-tränade <strong>Envis</strong> (e. Lome Brage) startar i onsdagens mest penningstinna lopp när Dubbelcupens final med 200.000 kronor till vinnaren körs på Bergsåker (första start 18.27).<br>Envis har firat framgångar under sina två första säsonger på banan. Ifjol slutade han fyra i norska Kriterietoch i år blev det en bronsplats i norska Derbyt, medan han galopperade bort en topp fyra-placering i svenska Derbyt i somras. </p>



<p>Att möta äldre hästar är dock inget nytt för envis, som bland annat vann det näst sista försöket i denna omgång av dubbelcupen. Nu ska han främst försöka hålla undan för två andra tidigare Derbyfinalister, Ola Åsebös <strong>Soldhöjdens Drake</strong> (e. Lome Brage) och David Nylanders <strong>Dellenit</strong> (e. B.W.Modde) som startar 20 meter bakom, samt forne norske Derbytvåan <strong>Pydin</strong> (e. Moe Brage) ytterligare 20 meter bakom.<br>Den trefaldige miljonären har hunnit bli elva år, men gör åter en stark säsong. Bland annat utklassade han Månlykke A.M. och Bäcklös Uriel i våras. </p>



<p>Ytterligare ett kallblodslopp får plats på V86-kupongen, då 14 fem- och sexåriga ston möts över medeldistans. Från trippla tillägg tar Öystein Tjomsland ut fjolårets Derbystofemma <strong>Ragnhild W.M.</strong> (e. Tekno Odin). Hinner hon ifatt starthästarna med Olle Alséns <strong>Dån Klara</strong> (e. Klack Jo) i spetsen?</p>



<p>Gävletränaren Olle Alsén har starthäst i båda loppen – <a href="https://sulkysport.se/infor-v86-form-slar-klass/" target="_blank" rel="noreferrer noopener">läs mer här!</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2Solvalla (första start 18.15) delar expressomgången med Sundsvallsbanan och efter förra onsdagens avslutning av V86 Super Days, som innebar jackpot på sex rätt, så har över 15 miljoner kronor gått över till kvällens åttarättspott.</p>



<p>På Solvalla sticker Traveraloppet ut. Det är ett av få lopp på svensk mark som körs enligt ”fri handicap”, alltså i det här fallet Solvallas sportchef Anders Malmrot som placerar ut de anmälda hästarna på lämplig startvolt utan direkt hänsyn till prissumma, för att få ett så jämnt lopp som möjligt.<br>Det innebär att 15 hästar startar från fyra olika volter med den fattigaste <strong>Touch The Clouds </strong>(e. Carat Williams) med 55.900 kronor på kontot på startfållan, medan dubbelmiljonären <strong>Ubiquarian Face</strong> (e. Joke Face) inleder Ubiquarian Face från 60 meters tillägg. 150.000 kronor är förstapriset i loppet, som är öppet för hästar som sålts på Traveras interneauktioner.</p>



<p>I övriga rullar Solvallaseriens femte meeting vidare och Daniel Redén-tränade <strong>Poleposition</strong> (e. Propulsion) står perfekt inne i högsta klassen, stängd vid 650.000 kronor. Hästen har varit nära att kvala in till både Kriteriet (fyra i försöket) och Derbyt (trea) och väntar på de större prischeckarna. Nu kommer han närmast från start i det uttagningslopp till Europaderbyt som <strong>Barack Face</strong> (e. Ready Cash) vann. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/10/11v86.pdf">Här kan du ta del av dagens startlistor till tävlingarna på Bergsåker och Solvalla.</a></p>



<p><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/251721_V86_2023-10-11_40_1">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2023-10-11_40_1">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3Den forne Elitloppsdeltagare <strong>Seismic Wave</strong> (e. Explosive Matter) har efter tre och ett halvt år i Timo Nurmos regi bytt tränare.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/seismicwaveadam-617x333.jpg" alt="" class="wp-image-168937"/><figcaption class="wp-element-caption">Seismic Wave har bytt regi. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Stall Dalhems åttaårige valack – som faktiskt var favorit i ett Elitloppsförsök år 2021 – har inte vunnit lopp sedan han dundrade runt på 1.10,0a/1.640 meter i ett snabblopp på Färjestad i november just Elitloppsåret och testas nu hos Östersundsproffset Oscar Berglund.<br>– <em>Verktygslådan är full med av verktyg för att kunna vara en toppindivid men det gäller att det fungerar också</em>, <a href="https://www.travronden.se/travsport/handel/hastagande/tranarbyte/a/seismic-wave-fran-nurmos-till-oscar-berglund" target="_blank" rel="noreferrer noopener">säger Oscar Berglund till Travronden.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4Det står med holländska mått mätt stora pengar på spel när Fokkers Trofee (€30.580) avgörs för treåriga, inhemska hästar på Wolvega (första start kl. 17.30) denna onsdagkväll.</p>



<p>Det har dock inte utmynnat i någon rusning för att tävla om segerchecken på 13.500 euro utan tvärtom så är det endast fyra hästar med i startfältet. Bland dem finns de fyra främst placerade hästarna från det Holländska Derbyt som avgjordes den 24 september med fjolårets Breeders Course-vinnare <strong>Novato</strong> (e. Maharajah) som segrare.</p>



<p><strong>Startlista Fokkers Trofee hingstar/valacker</strong><br><em>2.100 meter autostart, förstapris: 13.500 euro</em></p>



<ol class="wp-block-list">
<li>Nicolas Matisse (e. Brillantissime) – Marciano Hauber</li>



<li>Novato (e. Maharajah) – Jeffrey Mieras</li>



<li>Nevada Lobell (e. Love You) – Jaap van Rijn</li>



<li>Napoli (e. Broadway Fortuna) – Thomas Bos</li>
</ol>



<p><strong>Startlista Fokkers Trofee ston</strong><br><em>2.100 meter autostart, förstapris: 9.600 euro</em></p>



<ol class="wp-block-list">
<li>Nirvana Fashion (e. Ufo Kievitshof) – Stefan Schoonhoven</li>



<li>Niagara River (e. Orlando Vici) – Danny Brouwer</li>



<li>Nicole Baldwin (e. Virgill Boko) – Bas Crebas</li>



<li>Noa Tranns R (e. Brillantissime) – John Dekker</li>



<li>Noillusion (e. Muscle Mass) – Caroline Aalbers</li>



<li>Newsunshine (e. Broadway Fortuna) – Jan Baas</li>



<li>Nadyha (e. Crazed) – Jaap van Rijn</li>
</ol>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5När <strong>Cabaret Bi</strong> (e. Love You) vann lopp i Mantorp under måndagskvällen så passerade Håkan K Persson fjolårets segerantal som tränare och står nu på 32 fullträffar.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/07/hkankpersson-617x333.jpg" alt="" class="wp-image-9418"/><figcaption class="wp-element-caption">Håkan K Persson. Leif Norberg ALN</figcaption></figure>



<p>Nyligen har han stärkt upp med ytterligare en häst med potential då Tui Southwind (e. Readly Express) 1.12,4ak/249.800 kr numera finns hos Halmstadtränaren. Stoet kommer närmast från David Källgren, vann sin näst senaste start och står totalt med fyra fullträffar på 22 försök.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6Gott om svenskintressen är det ont om när det tävlas på Enghien (första start kl. 13.50) under onsdagseftermiddagen.</p>



<p>Pierre Levesques svenskfödde <strong>Iliade</strong> (e. Varenne) är ensam om att försvara de blågula färgerna då hon kommer till start i Prix de la Porte de Saint-Mande (€46.000) över 2.150 meter autostart med 20.700 euro i segerpremie.</p>



<p>Alexandre Abrivard kör stoet som noterats för fyra andraplatser som bäst på årets åtta starter.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/enghien-2023-10-11/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Enghien.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7Efter att inlett karriären med tio raka segrar så gick Mattias Djuse-tränade <strong>Winterburn</strong> (e. Ready Cash) på pumpen för första gången vid gårdagens lunchtävlingar i Bollnäs.</p>



<p>Magnus A Djuse körde valacken som hade grepp om loppet från dödspositionen efter efter fem månaders tävlingsfrånvaro, men som fick sträcka vapen i sista stegen då 93-oddsaren <strong>Heavenly May </strong>(e. Yarrah Boko) spurtade förbi efter att hittat loss ur tredje invändigt i lag med Marcus Lilius.</p>



<p>Den sistnämnda vann med hals som marginal och duon noterades båda för 1.14,5a/2.640 meter.<br>Heavenly May noterades för karriärens blott andra seger i karriärens 89:e start (!) och 2019 års Oaksfinalist har hela tiden funnits i Thomas Lönns regi.</p>

Fokustema
Morgonsvepet
Läs senare
Ungdomlig entusiasm?
Om kvällens penningstinna kallblodslopp på Bergsåker, handicapdrabbningen för auktionshästar på Solvalla och en Oaksfinalist som sänkte en segerstaplare går bland annat att läsa i veckans tredje morgonsvep.
