
<p class="has-drop-cap">127.692.629 kronor! Så mycket extra ligger i åttarättspotten i kvällens multijackpot när V86 Super Days når sin final. Solvalla och Jägersro delar på expressomgången med spelfokus.</p>



<p>Sulkysports spelstuga med viktiga punkter, favoriter i fara och systemförslag publiceras som vanligt klockan 12.00 idag.</p>



<p>I måndags hade Sulkysports sju rätt på Super Days-systemet och varje andel för 95 kronor gav 2.102 kronor tillbaka!</p>



<p><em>Vill du spela V86 tillsammans med Sulkysport finns följande alternativ i andelsspelet hos Andelskungen:</em></p>



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



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



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



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



<p class="has-drop-cap">2Breeders Course-finalen är årets första stora tvååringslopp på svensk mark och ikväll på Jägersro (första start 18.27) är det dags för tolv ungdomar att tävla om 700.000 kronor i förstapris.</p>



<p>Snabbaste försöksvinnaren var Henrik Hollsten-tränade<strong> Follow Him</strong> (e. Father Patrick), som tillsammans med Wim Paal dundrade tunt första varvet på 1.11,4 i stor ledningen. Det mattades av rejält till slut, men Follow Him kom hem på 1.13,9a/1.640 meter vid överlägsen seger.<br>– <em>Han blev uppskruvad efter provstarten, men jag ville inte bråka med honom utan han fick gå i sin egen fart</em>, sade segerkusken Wim Paal efteråt.</p>



<p>Follow Him är en av sex finalister som är födda i Italien. Av övriga är fyra svenska och två födda i Norge.</p>



<p>Hemmatränaren Per Nordström dominerar annars på tränarsidan. Hela fyra av stallets tvååringar har kvalat in till kvällens final och själv kör han stoet <strong>Zipzeronada</strong> (e. Googoo Gaagaa), som är lillasyster till vinnaren av Svensk Uppfödningslöpning 2018: <strong>Bythebook</strong> (e. Googoo Gaagaa).</p>



<p><strong>Breeders Course för tvååringar har körts sedan 2014 och det har bjudits på fem svensktränade vinnare:</strong></p>



<ul class="wp-block-list">
<li>2014 Mister J.P. (e. Taurus Dream) – Björn Goop</li>



<li>2016 Current Affair (e. Love You) – Tomas Malmqvist</li>



<li>2016 Ethien du Vivier (e. Sancho Turgot) – Tomas Malmqvist</li>



<li>2018 Amelie Grif (e. Varenne) – Björn Goop</li>



<li>2020 Mellby Jinx (e. Ready Cash) – Svante Båth</li>
</ul>



<p>*2016 kördes två finaler för tvååringarna, en i september och en i oktober.</p>



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



<p class="has-drop-cap">3I Solvallas (första start 18.15) onsdagssatsning Solvallaserien med ett antal försök och sedan final går det fjärde meetinget i mål ikväll. Finalen i högsta klassen har tyvärr bara lockat nio hästar, men kvaliteten är det inget fel på. Här plockar nämligen Per K Eriksson ut <strong>Lozano di Quattro</strong> (e. Trixton), som imponerat storligen i tre raka segrar.</p>



<p>De två senaste har tagits o bronsdivisionsförsök och efter kvällens start väntar finalen på Solvalla den 14 oktober.</p>



<p>Annars lär det handla en hel del om Timo Nurmos denna onsdagkväll. I Solvallaseriens övriga finaler har han segermaskinerna <strong>Miro Boko </strong>(e. Royalty For Love) med fem vinster på sju starter samt <strong>Live To Tell</strong> (e. Villiam) med fyra segrar på fem framträdanden. Duon har aldrig varit sämre än tvåa i lopp.</p>



<p>Dessutom kryddar Nurmos med en obesegrad årsdebutant i en spårtrappa. Det handlar om nu femårige <strong>Isco Am </strong>(e. Father Patrick), som åldern till trots bara hunnit med fem starter. När han gjorde comeback förra hösten efter tio månaders uppehåll segrade valacken på 1.13,2am på Solvalla i livets tredje start!</p>



<p>Även på Solvalla vankas tvååringslopp, nämligen Solvalla Hästägarförenings Tvååringspris med 100.000 kronor till vinnaren. Svante Båth, som igår avslöjade att han slutar som travtränare vid årsskiftet, startar till ämne<strong> Duncan Cowan </strong>(e. Walner), som inledde karriären med två raka segrar innan han gick på pumpen i ett Breeders Crown-lopp i senaste starten. Nu ställs han bland annat mot Daniel Wäjerstens <strong>Global Fearless</strong> (e. Booster Winner), som också segrat i två av tre starter i karriärens linda.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/09/04v86onsdag.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">4Mot Le Mans (första start kl. 13.50) riktas många blickar under den tidiga eftermiddagen då Grupp III-klassade Grand Prix Anjou-Maine (€100.000) lockat ett riktigt drömfält.</p>



<p>Årets Prix d&#8217;Amerique- och Elitloppsvinnare <strong>Hooker Berry </strong>(e. Booster Winner) samt <strong>Hohneck</strong> (e. Royal Dream) gör comeback efter drygt sju respektive två och en halv månads tävlingspaus, men ska tävla på skor.<br>Favoritskapet kan mycket väl komma att riktas mot titelförsvararen <strong>Elie de Beaufour</strong> (e. Royal Dream) som är Jean-Michel Bazires kuskval i loppet, men även segervane Gitano (e. Tucson) som startar 25 meter före lär ha många förespråkare.</p>



<p><strong>Startlista Grand Prix Anjou-Maine</strong><br><em>2.950 meter voltstart, förstapris: 45.000 euro</em></p>



<ol class="wp-block-list">
<li>Gaspar de Brion – Matthieu Abrivard</li>



<li>Fakir de Mahey – Yoann Lebourgeois</li>



<li>Ina Du Rib – Jean-Loïc Claude Dersoir</li>



<li>Fine Perle of Love – Eric Raffin</li>



<li>Goeland d’Haufor – Damien Bonne</li>



<li>Gitano – Théo Duvaldestin</li>



<li>Hip Hop Haufor – Christian Bigeon</li>



<li>Fulton – Tristan Ouvrie<br><em>25 meters tillägg:</em></li>



<li>Izoard Vedaquais – Benjamin Rochard</li>



<li>Fire Cracker – Anthony Barrier</li>



<li>Hanna des Molles – Alexandre Abrivard</li>



<li>Etoile de Bruyere – Christian Dreux</li>



<li>Elie de Beaufour – Jean-Michel Bazire</li>



<li>Granvillaise Bleue – Pierre Levesque</li>



<li>Hooker Berry – Nicolas Bazire</li>



<li>Hohneck – Gabriele Gelormini</li>
</ol>



<p>Svenskintresse går även skönja i Le Mans. I sadelloppet Prix Ccmb (€34.000) tävlar Johan Untersteiners <strong>Racing Ribb</strong> (e. Raja Mirchi) och Tomas Malmqvists <strong>Devs Definitif</strong> (e. Infinitif) och i Prix Passenaud (€26.000) startar Björn Goops <strong>Twigs Honor</strong> (e. Voltigeur de Myrt).</p>



<p>Den sistnämnde är obesegrad under sadel efter två försök och rids precis som vid de tidigare triumferna av Jonathan Carre.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/le-mans-2023-10-04/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/le-mans-2023-10-04/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Le Mans.</a></p>



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



<p class="has-drop-cap">5 När <strong>Warrior&#8217;s Tale</strong> (e. Raja Mirchi) vann lopp på Halmstadtravet under måndagskvällen grejade han Helena Burmans sista seger som A-tränare.<br>– <em>Det känns oerhört bra. En stor lättnad. Detta var sista starten för mig och nu går hästen över till Adrian Kolgjini. Jag har bara fyra hästar i träning och det går inte att livnära sig på. Jag måste göra något annat. Vad det blir återstår att se</em>, sade Helena Burman till TV12.</p>



<p>Burmans största seger i karriär noterades år 2013 då <strong>Tiberius F. </strong>(e. Going Kronos) vann korta E3-finalen, men i det skedet var Burman alltjämt B-tränare.<br>Därefter har toppnamn som <strong>The Bucket List F.</strong> (e. Raja Mirchi) med dubbla Vincennes-segrar på sitt cv samt Guldstovinnaren<strong> A Sweet Dance</strong> (e. Maharajah) utmärkt sig lite extra.</p>



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



<p class="has-drop-cap">6Björn Goop har lyckats väl med hästar ägda av Scuderica Sant&#8217;Eusebio SNC Di Rocca under årens lopp med<strong> Balsamine Font</strong> (e. Filipp Roc) som toppnamn.</p>



<p>Nu har Färjestadtränaren fått en ny intressant, italienskfödd springare till sitt stall från samma ägare då <strong>Daytona Roc</strong> (e. Filipp Roc) 1.12,1ak/538.448 kr anslutit hos Goop.</p>



<p>Daytona Roc var femma i finalen av Oaks del Trotto under fjolåret, men har gått segerlös i åtta starter detta år och nu blir det Goops uppgift att försöka hitta ny kraft i det fyraåriga stoet.</p>



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



<p class="has-drop-cap">7Gårdagens stortävlingar från tyska Hamburg med Johan Untersteiners<strong> Global Dubhe</strong> (e. Brillantissime) som vinnare av huvudloppet Grosser Preis von Deutschland rönte ett klart större intresse från spelarna kontra vad det gjorde under fjolåret.</p>



<p>Då omsatte V64-omgången 322.909 kronor, men i år stack den iväg till 726.987 kronor.<br>Utdelningen stannade dock på 608 kronor på sex rätt och 17 kronor på fem rätt varpå  jackpotpengar från fyrarättspotten vandrar vidare till torsdagens V64-tävlingar som avgörs på Åby.</p>

Fokustema
Morgonsvepet
Läs senare
Miljonregn på V86?
Om kvällens jackpotkryddade V86-omgång, den penningstinna Breeders Course-finalen på Jägersro och mötet mellan Prix d'Amerique och Elitloppsvinnaren i Le Mans kan du bland annat läsa i veckans tredje morgonsvep.
