
<p class="has-drop-cap wp-block-paragraph">1Den franska facktidningen Paris-Turf bringar klarhet i matchningsplanerna för söndagens topptrio i Prix d&#8217;Amerique.<br>Thierry Duvaldestin tycks ytterst tillfreds med hur vinnaren <strong>Idao de Tillard</strong> (e. Severino) tog det tuffa lopp han fick i PDA och har inte märkt några omedelbara krämpor dagen efter segern.<br>– <em>Idao de Tillard var ivrig att komma ut i sin gräshage och njuta av det soliga vädret under måndagen. Finner vi inget som stör honom de närmsta dagarna så är planen att han ska starta i Prix de France söndag den 11 februari och så kan det bli så att vi avslutar vintermeetinget med start i Prix de Selection den 2 mars</em>, säger Duvaldestin till Paris-Turf.</p>



<p class="wp-block-paragraph">Även Jean-Luc Dersoir som tränar <strong>Hokkaido Jiel </strong>(e. Brillantissime) meddelar att Prix de France blir nästa uppgift för PDA-tvåan och det tycks även stunda för trean <strong>Joviality</strong> (e. Chapter Seven).<br>– <em>Verkar allt bra kan Prix de France bli nästa uppgift och därefter Criterium de Vitesse i mars</em>, säger Anders Ström till Paris-Turf.</p>



<p class="wp-block-paragraph">Skulle Idao de Tillard följa upp seger i Prix d&#8217;Amerique med triumf i Prix de France så blir han den förste att lyckas med den saken sedan Bold Eagle tog hem dubbeln år 2017.<br>Fjolårets Prix d&#8217;Amerique-vinnaren <strong>Hooker Berry</strong> (e. Booster Winner) fick nöja sig med en sjundeplats i Prix de France.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Över tio miljoner kronor extra ligger i åttarättspotten i kvällens V86-jackpot som delas mellan Solvalla och Bergsåker.</p>



<p class="wp-block-paragraph">En häst som skulle fått bära tungt favorittryck på Solvalla (första start 18.15) var Katja Melkko-tränade stoet<strong> Relevant Stride </strong>(e. Maharajah), men hon har blivit struken från sitt lopp liksom Öystein Tjomslands <strong>Ängsborken</strong> (e. Bork Odin) blivit i sin motsedda comeback på Bergsåker.</p>



<p class="wp-block-paragraph">Det öppnar upp V86-omgången markant och Sulkysports spelstuga med spikar, drag, viktiga punkter och favoriter i fara på V86 publiceras som vanligt klockan 12.00.</p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-01-31_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a class="" href="https://www.atg.se/andelskungen/spel/206235_V86_2024-01-31_40_1">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3På Bergsåker (start 18.27) hedras en av 1990-talets stora hjältar på svenska travbanor, och för en del patrioter säkerligen den störste, nämligen <strong>Zoogin</strong> (e. Zoot Suit). I Åke Svanstedts händer blev hästen en av Europas absolut bästa hästar och när karriären summerades var meritlistan minst sagt lång. 51 segrar på 96 starter och 25.346.330 kronor på priskontot för Zoogin till en av svensk travsports största.</p>



<p class="wp-block-paragraph">Blott fyra svenskfödda hingstar och valacker (och stoet Joviality efter söndagens tredjeplats i Prix d’Amérique) har tjänat mer än Zoogin. <strong>Victory Tilly</strong> (37,7 miljoner) toppar listan följd av <strong>Commander Crowe</strong> (34,3), <strong>Gidde Palema</strong> (27) och <strong>Torvald Palema</strong> (26,7).</p>



<p class="wp-block-paragraph">Zoogin lämnade jordelivet kort efter sin 30-årsdag sommaren 2020 i Ryssland där han verkat som avelshingst.</p>



<p class="wp-block-paragraph">Ikväll bär ett flerklasslopp över lång distans med 60.000 kronor till vinnaren Zoogins namn och loppet är placerat utanför V86-kupongen. Lars Wikströms <strong>Huddlestone</strong> (e. Brad de Veluwe) och Hanna Forslins <strong>Xanthis Coktail</strong> (e. Andover Andover) startar längst bak på varsin volt, där Huddlestone klarar sista tilläggsgränsen med knappt 5.000 kronors marginal.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/01/31v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar.</a></p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/01/huddlestonehs-617x333.jpg" alt="" class="wp-image-402517"/><figcaption class="wp-element-caption">Lars Wikström-tränade Huddlestone kommer till start på Bergsåker. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">4Svenskarna lyser med sin frånvaro i dagens Grupp III-lopp Grand Prix de Vincennes (€80.000) i Cagnes-sur-Mer (första start kl. 16.35) trots att det handlar om ett EU-lopp.</p>



<p class="wp-block-paragraph">Sju- till elvaåriga hästar som tjänat upp till 680.000 euro drabbar samman och de är fördelade över två olika volter.</p>



<p class="wp-block-paragraph">De riktiga affischnamnen lyser med sin frånvaro, men sannolikt kommer favortiskapet få delas med tilläggshästarna <strong>Eden Basque</strong> (e. Singalo) och <strong>Echo de Chanlecy</strong> (e. Quinoa du Gers) i detta lopp där vinnaren belönas med 36.000 euro.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Alessandro Gocciadoro har fått två tyskfödda hästar i träning ägda av Patrick Maleitzke som närmast kommer från Johan Untersteiners stall.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/sierras.ju-617x333.jpg" alt="" class="wp-image-473967"/><figcaption class="wp-element-caption">Sierra S. för sin tidigare tränare Johan Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Sierra S. </strong>(e. Father Patrick) 1.13,0am/€56.363 hade en stark treåringssäsong hos Halmstadtränaren med dubbla seger i 100.000 kronorslopp samt finaldeltagande i Breeders Course för ston under Elitloppsdagen.</p>



<p class="wp-block-paragraph">Nu tar hon sats i ny regi liksom <strong>Lauria Inferior S.</strong> (e. Muscle Hill) 1.12,0ak/€31.572 som är en dotter till Gocciadoros forna storstjärna Linda de Casei.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Fjolårets Finlandia Ajo-trea <strong>Global Withdrawl </strong>gör ikväll comeback I ett snabblopp I finska Lahti.<br>Matias Salo tränar den nioåriga S.J.’s Caviar-sonen vars fjolår blev rumphugget med blott sju framträdanden varav den senaste kom i november.</p>



<p class="wp-block-paragraph"><strong>Startlista</strong><br><em>2.140 meter autostart, förstapris: 3.000 euro</em></p>



<ol class="wp-block-list">
<li>Lexus Dream – Tapio Perttunen</li>



<li>Hazelhen Hermes – Tino Paldan</li>



<li>Jason’s Camden – Tommi Kylliäinen</li>



<li>Van Kronos – Hannu Korpi</li>



<li>Super Schissel – Antti Teivanen</li>



<li>Deep Blue Font – Olli Koivunen</li>



<li>Global Withdrawl – Santtu Raitala</li>



<li>M.S.Triple J. – Jukka Torvinen</li>



<li>Sahara Sandstorm – Ville Tonttila</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7Solvalla har tagit över sommarens andra STL-finaler vilka kommer att avgöras under Jubileumskvällen den 14 augusti.</p>



<p class="wp-block-paragraph">Dess inträde under tävlingskvällen i kombination med Åby World Grand Prix fyra dagar innan samt E3-finaler i Gävle tre dagar senare gör nu att Solvalla gör två förändringar i lopputbudet.<br>– <em>Big Noon Pokalen för tre- och fyraåringar kommer att byta plats liksom Wallenius Cup som körs för treåriga ston. Det blir helt enkelt för tajt inpå de andra storloppsdagarna och kommer istället köras senare på året, men det är ännu inte helt bestämt när det blir</em>, säger Solvallas sportchef Anders Malmrot.</p>

Fokustema
Morgonsvepet
Läs senare
Så matchas PDA-topparna
Om matchningsplanen för Prix d'Ameriques topptrio, Finlandia Ajo-trea i comeback samt två svenska storlopp som får finna ny plats i kalendern går bland annat att läsa i veckans tredje morgonsvep.
