
<p class="has-drop-cap">1I morgon och på fredag är det auktion på Åby med ettåringar i fokus i regi Sweden International Yearling Sales. Upptakten sker ikväll på Åby med två auktionslopp för hästar som sålts på Yearling Sales auktioner. Tvååringarnas uppgörelse har lockat tolv deltagare i kamp om en kvarts miljon kronor i förstapris.</p>



<p>Fyra av tvååringarna har redan vunnit lopp och bland dessa finns Fredrik Wallin-tränade stoet <strong>Chapter One </strong>(e. Chapter Seven), som i sin senaste start vann försök i Breeders Course. Nu vässas formen till den finalen nästa onsdag – 700.000 kronor i förstapris – med att försöka knipa 250.000 kronor i auktionsloppet.</p>



<p>Per Nordströms <strong>Captiva</strong> (e. Walner) vann årets första tvååringslopp på svensk mark, på Jägersro den 1 augusti, och återkommer nu efter två månaders tävlingsuppehåll. Obesegrad efter en start är även Steen Juuls svenskfödde ämne <strong>He Dares The Devil </strong>(e. Fourth Dimension), som travade 1.15,4am på Charlottenlund för två veckor sedan. Även Jasmine Isings<strong> R.K.Fade</strong> har hunnit besöka vinnarcirkeln.</p>



<p>Fyraåringarna har också ett eget auktionslopp med 150.000 kronor till vinnaren, där Jörgen Westholm plockar ut färske STL-vinnaren <strong>Jobspost</strong> (e. Readly Express) mot en trio från Johan Untersteiners stall med <strong>Windmill Jam </strong>(e. Ready Cash) i spetsen.</p>



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



<p class="has-drop-cap">2Åby (första start 18.27 delar kvällens expresstrav med Solvalla (start 18.15) och snabblopparna får chansen på båda banorna. Åby sprinterlopp The Red Mile är placerat på V86-kupongen, medan Solvallas spårtrappa avgörs före V86.</p>



<p>Alessandro Gocciadoro tar ut ett sto mot hingstarna i varje snabblopp. <strong>Clarissa</strong> (e. Exploit Caf) spände bågen mot Francesco Zet &#038; Co i Margareta Wallenius-Klebergs Pokal senast, men gjorde bort sig med galopp. Nu ställs hon mot Elitloppshästen <strong>Ultion Face</strong> (e. Joke Face) och mångmiljonären<strong> Usain Töll</strong> (e. Googoo Gaagaa) på Åby.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2020/03/ultionface3.jpg" alt="" class="wp-image-78293"/><figcaption class="wp-element-caption">Ultion Face. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p><strong>Zeudi Amg</strong> (e. Ideale Luis) hade inte heller någon lyckad kväll på Solvalla i augusti, när hon tröttnade efter en tung resa i European Championship for Mares. <strong>Brambling</strong> (e. Bold Eagle) i första starten på drygt fyra månader, evighetsmaskinen <strong>Milliondollarrhyme</strong> (e. Ready Cash),<strong> Rome Pays Off</strong> (e. Muscle Hill) och <strong>Seismic Wave </strong>(e. Explosive Matter) finns bland motståndarna.</p>



<p>På Solvalla drar också årets femte meeting av Solvallaserien igång och i högsta klassen plockar Daniel Redén ut segermaskinen <strong>Hankypanky Pinkman </strong>(e. Love You), som fick segerraden i Redéns regi bruten i senaste starten, där han slutade trea i klass I-finalen på Åby.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/09/27v86onsdag.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">3Sedan början av juni har ATG samlat in 20 procent av alla jackpotpengar på V86 och ikväll drar slutfasen av V86 Super Days igång med V86-spel alla vardar fram till den stora multijackpotomgången som delas mellan Solvalla och Jägersro nästa onsdag.</p>



<p>Hittills har 24,2 miljoner kronor samlats in till åttarättspotten nästa vecka och alla eventuella jackpotpengar i de kommande omgångarna läggs in i potten.</p>



<h2 class="wp-block-heading">Schema V86 Super Days:</h2>



<ul class="wp-block-list">
<li>Onsdag 27 sep: Solvalla/Åby</li>



<li>Torsdag 28 sep: Bergsåker/Örebro</li>



<li>Fredag 29 sep: Axevalla/Romme</li>



<li>Måndag 2 okt: Bollnäs/Halmstad</li>



<li>Tisdag 3 okt: Eskilstuna/Bjerke</li>



<li>Onsdag 4 oktober: Solvalla/Jägersro – multijackpot!</li>
</ul>



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



<p><a href="https://www.atg.se/andelskungen/spel/206233_V86_2023-09-27_40_1" data-type="link" data-id="https://www.atg.se/andelskungen/spel/206233_V86_2023-09-27_40_1" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206235_V86_2023-09-27_40_1" data-type="link" data-id="https://www.atg.se/andelskungen/spel/206235_V86_2023-09-27_40_1" target="_blank">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">4Dagens högst doterade lopp på europeisk mark avgörs dock i franska Le Mont Saint Michel (första start kl. 13.50).</p>



<p>Där körs årets elfte etapp av den rikstäckande löpningsserien Grand National du Trot (€90.000) och förhandsfavoriten<strong> Horace du Goutier </strong>(e. Ready Cash) har räknat hem fem av de föregående tio.</p>



<p>För två veckor sedan vann han etappen i Angers närmast följd av <strong>Gigolo Lover </strong>(e. Royal Lover) som även finns med i dagens lopp och det gör även Jean Michel Baudouins <strong>Gaspar d&#8217;Angis</strong> (e. Quaro) som vunnit fyra GNT-etapper under året!</p>



<p>Tävlingsdagens svensklopp är Prix des Enterprises Rault Fendt (€30.000). Fyra svenskfödda hästar tävlar om segerchecken på 13.500 euro då såväl Markus B Svedbergs <strong>Kimi di Quattro</strong> (e. Maharajah), Jörgen S Erikssons <strong>Dollar Doc</strong> (e. Ready Cash), Tomas Malmqvists <strong>Digital Dominance</strong> (e. Super Photo Kosmos) som Mattias Djuses <strong>Global Bookmaker</strong> (e. Broadway Hall) finns med.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/06/dollardoc-1-617x333.jpg" alt="" class="wp-image-93735"/><figcaption class="wp-element-caption">Dollar Doc. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Till Le Mont Saint Michel får även Tomas Malmqvist ultrastammade treåring <strong>Karnac Wood</strong> (e. Ready Cash–Qualita Bourbon) bege sig för att starta i Prix Sarl Sarrazin (€30.000).<br>Franck Nivard kör hingsten som inledde karriären med tre raka segrar innan han fick nöja sig med en tredjeplats i Pornichet i mitten av augusti.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/le-mont-saint-michel-2023-09-27/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/le-mont-saint-michel-2023-09-27/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Le Mont Saint Michel.</a></p>



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



<p class="has-drop-cap">5Katja Melkko har starthäst på Vermo (första start kl. 17.07) denna onsdag då det avgörs Derbyrevansch på denna finska huvudstadsbanan.<br>Hennes bidrag <strong>Patriot Ale </strong>(e. Andover Hall) fick nöja sig med en sjätteplats i derbykvalet i mitten av augusti och är nu på jakt efter årets andra seger i vad som blir elfte försöket.</p>



<p>Bland loppets blott sju deltagare lyckades <strong>Massimo Hoist </strong>(e. Muscle Hill) bäst i Finskt Travderby med en tredjeplats i finalen.</p>



<p><strong>Startlista Derbyrevanschen</strong><br><em>2.120 meter autostart, förstapris: 5.000 euro</em></p>



<ol class="wp-block-list">
<li>Callela Nelson (e. Beer Summit) – Hannu Torvinen (Jukka Hakkarainen)</li>



<li>Laxvikens Amiral (e. Jontte Boy) – Tuomas Korvenoja</li>



<li>Phantom Opera (e. Jontte Boy) – Antti Teivanen (Markku Nieminen)</li>



<li>Amazing Player (e. Quite Easy) – Jarmo Saarela (Irina Sarin)</li>



<li>Patriot Ale (e. Andover Hall) – Ari Moilanen (Katja Melkko)</li>



<li>Massimo Hoist (e. Muscle Hill) – Tommi Kylliäinen (Jukka Hakkarainen)</li>



<li>Cupido Combo (e. Nuncio) – Iikka Korpi (Pekka Korpi)</li>
</ol>



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



<p class="has-drop-cap">6Andreas Lövdal startar spännande<strong> The Pirate </strong>(e. Great Challenger) inom dagens V86-omgång och snart avser han att låta ett annat nyförvärv göra debut i hans regi.<br>Det handlar om den fyraårige italienaren <strong>Delon Grif </strong>(e. Varenne) som noterade sitt urstarka rekord 1.13,1a/2.060 meter vid seger på 800 metersbanan i Aversa vid seger i april och som tjänat 262.707 kronor via sju segrar på 21 starter.<br>– Han har stått här sedan Elitloppshelgen. Det kom ett litet bakslag när jag började träna igång honom, men han har fått tid och acklimatiserat sig med den förändring som blir för en häst med att träna i backe. Jag har kört ett banjobb på Solvalla med honom och ska köra ett till innan det blir start. Jag får bra feeling när jag kör honom, säger Andreas Lövdal.</p>



<p><a href="https://sulkysport.se/infor-v86-piraten-intar-solvalla/(öppnas i en ny flik)" target="_blank" rel="noreferrer noopener">Här kan du läsa mer om Lövdals tankar inför kvällens lopp och hur han ser på starten som proffstränare.</a></p>



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



<p class="has-drop-cap">7Elitloppsdeltagaren Best ofdream Trio (e. Nad Al Sheba) stod för en slät figur i tisdagskvällens snabblopp på Bjerke.</p>



<p>Kim Eriksson sände sexåringen till tät och Erik Killingmos häst tilläts varva på moderata 1.13,6 om än i pigg stil, men hade kastat in handduken redan 300 meter före mål.</p>



<p>Istället segrade Frode Hamre-tränade<strong> Ble du Gers</strong> (e. Quinoa du Gers) från dödens i sin första start sedan i maj och kom i mål på 1.12,3a/2.100 meter vilket gav 30.000 norska kronor i belöning.</p>

Fokustema
Morgonsvepet
Läs senare
Juul och djävulen
Om kvällens auktionslopp på Solvalla, starka snabbloppsdeltagare och om en duo med hög segeraptit som drabbar samman i dagens högst doterade lopp på fransk mark går bland annat att läsa i dagens morgonsvep.
