
<p class="has-drop-cap wp-block-paragraph">1Segerloppet i UET Grand Prix blev <strong>Barack Face</strong> (e. Ready Cash) sista start för året.<br>– <em>Nu ska han få sex månader av bara träning, för att vara tillbaka runt maj, och om ett år och tre månader kan vi nog ge fransmännen en match på Vincennes när han har fyllt sex</em>, säger Adrian Kolgjini till Trav365 och tycks inte vara påtagligt intresserad av start i Elitloppet:<br>– <em>Det är i princip uteslutet i dag. Man kan säga det klassiska att hästen får bestämma matchningen. Vi kommer nog att satsa på andra halvan av säsongen då både Jubileumspokalen och Åby World Grand Prix, med sex miljoner till vinnaren, körs.</em></p>



<p class="wp-block-paragraph">Barack Face inledde säsongen med 643.000 kronor på kontot, men har sedan dess fyllt på med 5.185.500 kr och är en av sex svensktränade fyraåringar som tjänat över två miljoner denna säsong.</p>



<p class="wp-block-paragraph"><strong><em>Svensktränade fyraåringar som tjänat över två miljoner år 2023:</em></strong></p>



<ol class="wp-block-list">
<li>Joviality (10 starter, 6 segrar) – 6.314.500 kr</li>



<li>Barack Face (9 starter, 4 segrar) – 5.185.500 kr</li>



<li>Jennifer Sisu (7 starter, 3 segrar) – 2.837.500 kr</li>



<li>Joy Sisu (11 starter, 2 segrar) – 2.634.000 kr</li>



<li>Global Dancer (9 starter, 3 segrar) – 2.245.000 kr</li>



<li>Staro Mack Crowe (9 starter, 2 segrar) – 2.149.000 kr</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">225.777.979 kronor – så mycket extra ligger det i kvällens åttarättspott på V86! Förra veckan lyckades ju ingen klara alla rätt sedan det enda kvarvarande systemet inför sista avdelningen hade spikat Poleposition, som åkte dit från ledningen.</p>



<p class="wp-block-paragraph">Solvalla (start 18.15) och Jägersro (start 18.27) delar omgången och kvällens höjdare kan bli ett lopp på huvudstadsbanan för hästar upp till 2,5 miljoner kronor intjänat, där fyra (!) tidigare STL-finalvinnare möts.</p>



<p class="wp-block-paragraph">Dubbelmiljonären <strong>Remarkable Feets</strong> (e. Andover Hall) triumf ligger längst tillbaka i tiden. I februari 2020 segrade han i bronsdivisionsfinalen på Solvalla. <strong>Hipster Am </strong>(e. Muscle Hill) vann en bronsfinal i Eskisltuna förra sommaren, <strong>Hannibal Face</strong> (e. Bold Eagle) tog hem finalen i samma klass annandag jul förra året, medan <strong>Lindysmusclemania</strong> (e. Muscle Hill) var kvar i klass I när han vann final på Bergsåker i somras.</p>



<p class="wp-block-paragraph">Ur kvartetten noteras att Hannibal Face debuterar i ny regi. Hästen gick efter försäljning från Adrian Kolgjini till Oscar Berglund förra sommaren och  van sex av elva starter hos Östersundstränaren innan han i början av sommaren flyttades till Björn Goop.</p>



<p class="wp-block-paragraph">Solvallaserien rullar vidare med bekanta och obekanta namn i startfälten. I mellanklassen gör tjeckiske <strong>Jerry</strong> (e. Wine and Blues) sin andra start på svensk mark. Efter en lysande debut i Eskilstuna för två veckor sedan ser Sybille Tinters exotiska inslag ut att bli favorit i kvällens lopp och här kan du läsa mer om hennes tankar inför starten.</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_2023-10-18_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206235_V86_2023-10-18_40_1" class="">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">3Idag avgörs den tolfte etappen av den franska, rikstäckande löpningsserien Grand National du Trot (€90.000) i champagnestaden Reims.</p>



<p class="wp-block-paragraph">Jean Michel Baudouins <strong>Gaspar d&#8217;Angis</strong> (e. Quaro) har täljt guld i löpningsserien och vunnit fem av årets etapper tillsammans med Eric Raffin som även kör valacken i dagens lopp.<br>Främste utmanare på pappret ser Thierry Duvaldestin-tränade <strong>Gitano</strong> (e. Tucson) ut att vara i lag med Théo Duvaldestin.</p>



<p class="wp-block-paragraph">Loppet avgörs utan svenskintresse, men det finns blågula inslag i anda lopp. I Prix Toyota Reims (€23.000) för treåringar bidrar Tomas Malmqvist med<strong> Ksar du Rieu</strong> (e. Express Jet) och i sadelloppet Prix Nouveaux Partenaires PMU (€30.000) syns såväl Yves Desmets svenskfödde <strong>Beethoven</strong> (e. From Above) som Jörgen Westholms <strong>Ara</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph">Den sistnämnde har även starthäst i Cabourg (första start kl. 16.27) då <strong>Made of Stars</strong> (e. Super Photo Kosmos) möter Stefan Arvidsson<strong> G.K.Justus</strong> (e. Brad de Veluwe) i Prix des Tourterelles (€29.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/reims-2023-10-18/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Reims.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Robert Bergh har numera åter basen för träningsverksamheten i Hajom och har bytt Bergsåker mot Åby. Till Jägersro reser han med två hästar, där <strong>Carroty</strong> (e. Readly Express) kommer med färsk STL-seger i bagaget, då hon plockade hem diamantstoförsöket på Åbys SM-dag.</p>



<p class="wp-block-paragraph">Den andra är segervane sonen till Berghs stjärnhäst<strong> Hilda Zonett </strong>(e. Spotlite Lobell), nämligen fyraårige <strong>Allan Zonett </strong>(e. Maharajah). Den urstarke hästen inledde förtroendeingivande med tre raka segrar från tävlingsdebuten i maj i år och ståtar nu med fyra vinster på nio försök.</p>



<p class="wp-block-paragraph">Ett litet men naggande gott fyraåringslopp ser hästar som Sprintermästarfinalisten <strong>Sunrise</strong>, fjolårets Breeders Crown-trea <strong>Olivia Coger</strong>, Alessandro Gocciadoros trefaldiga miljonärska<strong> Delicious Gar </strong>och <strong>Pour Mea Double </strong>med över fyra miljoner på kontot.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/10/18v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Axevallas Sylvesterloppet ska i år avgöras för fjärde gången under Nyårsafton och nu återgår man till originalpropositionen efter att gjort en justering under fjolåret och blott haft hästar startande på tre olika volter.</p>



<p class="wp-block-paragraph">I år kan de återigen komma att stå på fyra olika volter då propositionen lyder &#8221;<em>3-åriga och äldre lägst 225.001 kr. 2640 m. Tillägg vid vunna 475.001 kr. 40 m vid 950.001 kr. 60 m vid 1.900.001 kr</em>&#8221;.</p>



<p class="wp-block-paragraph">Förstapriset är garanterat till minst 500.000 kronor, men prismedel som ej betalts ut under Axevallas tävlingsdagar skjuts till i prispotten som kommer att växa.</p>



<p class="wp-block-paragraph">Ifjol belönades vinnaren <strong>Ferrari Sisu</strong> (e. Djali Boko) med rekordhöga 593.328 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Oskar Kylin Blom är ny tränare till STL-vinnaren <strong>Kash Keeper</strong> (e. Uncle Lasse) 1.11,2ak/699.900 kr efter att femåringen sålts på Travera-auktionen för två veckor sedan.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/07/oskarkylinblom-617x333.jpg" alt="" class="wp-image-101914"/><figcaption class="wp-element-caption">Oskar Kylin Blom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Bergviks Auktionstjänst köpte hingsten för 280.000 kronor vars fjolår innehöll seger i ett Klass I-försök, V75-loppet Oktoberstayern på Jägersro och i år har han varit tvåa i Lärlingseliten på Solvalla under Elitloppsdagen.</p>



<p class="wp-block-paragraph">Kash Keeper är halvbror till <strong>Call Me Keeper</strong> (e. Pine Chip) 1.10,6am/7.550.503 kr vars karriär innehöll segrar i Jämtlands Stora Pris, Seinäjoki Race, andraplats i Harper Hanovers lopp samt en femteplats i Prix d&#8217;Amerique.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Anmälningslistan är klar till det Grupp I-klassade storloppet Gran Premio Orsi Mangelli (€300.300) som avgörs i Turin onsdag den 1 november.</p>



<p class="wp-block-paragraph">E3-vinnaren tillika Derby del Trotto-segraren <strong>Expo Wise As</strong> (e. Ready Cash) finns med bland de 23 anmälda där den överväldigande majoriteten är italienskfödda.</p>



<p class="wp-block-paragraph">Svenskfödde <strong>Faen Troot</strong> (e. Readly Express–Giant Diablo) 1.14,6/€4.195 och tyskfödde <strong>Cincinnati Beach S</strong> (e. International Moni) 1.12,1/€67.842 är de enda icke italienska hästarna som anmälts till den öppna klassen.</p>



<p class="wp-block-paragraph"><a href="https://gaet.it/articolo.php?arc=daily&#038;item=2023101618070470" target="_blank" rel="noreferrer noopener">Definitiv anmälan ska vara gjord senast fredag den 20 oktober och anmälningslistan till såväl Gran Premio Orsi Mangelli som Gran Premio Orsi Mangelli Filly kan du finna här.</a></p>

Fokustema
Morgonsvepet
Läs senare
Barack gör bokslut
Att Europaderbyvinnaren har gjort sin sista start för året, om dagens storlopp i Frankrike samt att Oskar Kylin Blom stärkt upp stallet med en V75-vinnare går bland annat att läsa i veckans tredje morgonsvep.
