
<p class="has-drop-cap">1 <strong>Calgary Games</strong> i comeback, topptvååringar i Vinterfavoriten och jackpot på V86 med 8.593.023 kronor extra i potten. Det finns all anledning att rikta blickarna mot kvällens tävlingar på Solvalla (första start 18.15).</p>



<p>Sex veckor efter genomfört kvallopp på ”kvalvärldsrekordet” 1.11,7/2.140 meter voltstart tycker Timo Nurmos att hans obesegrade superhäst Calgary Games (e. Readly Express) är redo för tävlingsdebut. Det har gått över 14 månader sedan hingsten senast visade upp sig i tävlingssammanhang. Då krönte han en felfri fyraåringssäsong med seger i Europaderbyt på Åby och tog karriärens nionde seger på lika många starter.</p>



<p>Sedan dess har damerna stått i fokus och under premiärsäsongen som avelshingst på Menhammar lockade Calgary Games full bok på svensk mark: 150 ston. Samtidigt har han satts igång med träning under sensommaren och hösten och Timo Nurmos har gjort flera resor till Solvalla för att känna på sin topphäst i snabbjobb. Beskedet som gavs i kvalloppet var inget annat än lysande.</p>



<p>Ikväll är det allvar igen i Gösta Nordins lopp, där han ställs mot sju motståndare och blir megafavorit att förlänga segersviten och ta livets tionde seger.</p>



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



<p class="has-drop-cap">2 Vinterfavoriten för tvååringar på Solvalla kördes första gången 1979, då Sören Norberg segrade med <strong>Dan Holmbo</strong> (e. Fine Shot). Då handlade det om kort distans och distansen har växlat genom åren, men sedan 2011 har alla upplagor avgjorts över medeldistans. </p>



<p>Löpningsrekordet innehas av då Sten O Jansson-tränade <strong>Belker</strong> (e. Scarlet Knight), som travade 1.14,6 vid segern tillsammans med Torbjörn Jansson 2018. Belkers notering är fortsatt gällande svensk rekord för tvååriga hingstar och valacker över medeldistans med startbil. Svante Båth-tränade <strong>Go Green Pellini</strong> (e. Love You) är snabbast på sprinterdistans, då han travade 1.14,7a/1.640 meter 2010.</p>



<h2 class="wp-block-heading">Snabbaste vinnare över medeldistans i Vinterfavoriten:</h2>



<p><em>År, häst (far) – Kusk (tränare) – Segertid </em></p>



<ul class="wp-block-list">
<li>2018 <strong>Belker</strong> (e. Scarlet Knight) – Torbjörn Jansson (Sten O Jansson) – 1.14,6a</li>



<li>2021 <strong>Coquaholy</strong> (e. Orlando Vici) – Örjan Kihlström (Roger Walmann) – 1.14,8a</li>



<li>2015 <strong>Undine</strong> (e. Zola Boko) – Örjan Kihlström (Catarina Lundström) – 1.15,5a</li>



<li>2014 <strong>Cupido Sisu</strong> (e. Judge Joe) – Örjan Kihlström (Petri Salmela) – 1.15,6a</li>



<li>2020 <strong>Indigo Sisu </strong>(e. Chocolatier) – Ulf Ohlsson (Petri Salmela) – 1.15,7a</li>
</ul>



<p>Årets upplaga av Vinterfavoriten har alla förutsättningar att bli ett minnesvärt lopp när tvåan och trean från Svensk Uppfödningslöpning möts. Det handlar om Mattias Djuses sto <strong>Frustration</strong> (e. Fourth Dimension) och Riina Rekilä-tränade <strong>Vegas Wania </strong>(e. Father Patrick).</p>



<p>– <em>2.140 meter går bra, hon är stark, rejäl och lågpulsad. Det är flera fina hästar emot och ett bra tvååringslopp, men jag har tro på henne igen</em>, säger Mattias Djuse inför kvällens uppgift.</p>



<p><a href="https://sulkysport.se/v86-djuses-basta-segerchans/" target="_blank" rel="noreferrer noopener">Djuse har flera spännande hästar till start på Solvalla – läs mer här!</a></p>



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



<p class="has-drop-cap">3 Medan tvåan och trean i Svensk Uppfödningslöpning startar på Solvalla ikväll kliver vinnaren <strong>Fiftyfour</strong> (e. Fourth Domension) ut i årets sista Breeders Crown-lopp för tvååringar på hemmabanan Jägersro (start 18.27). Tomas Malmqvists talang har gjort nästan allt rätt hittills i karriären med fyra segrar på fem starter – ”plumpen” är tredjeplatsen Breeders Course-finalen för tvååringar i slutet av september.</p>



<p>Fiftyfour angav ju tonen redan när han vann årets första tvååringslopp på svensk mark på Jägersro under Åbergskvällen i juli och säsongens vassa prissumma 2.135.000 kronor kan förstärkas med ytterligare 175.000 kronor i kvällens BC-lopp, som är årets fjärde.</p>



<h2 class="wp-block-heading">Tidigare vinnare i Breeders Crown för tvååringar:</h2>



<ul class="wp-block-list">
<li>26 aug: Feel No Pain (e. Walner) – Daniel Wäjersten – 1.17,6am</li>



<li>21 sep: Kathy Hawk (e. Fourth Dimension) – Kevin Oscarsson (Stefan P Pettersson) – 1.14,3ak</li>



<li>5 okt: Kathy Hawk (e. Fourth Dimension) – Torbjörn Jansson (Stefan P Pettersson) – 1.16,4am</li>
</ul>



<p>Förutom V86-banorna blir det även lunchtrav på Umåker (första start 12.20). Där väntar Hästägarekannan för både varm- och kallblod med en dubbelmiljonär i vardera klass: <strong>Eder Bob </strong>(e. Crazed) respektive <strong>Don Viking</strong> (e. Järvsöviking).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2022/12/221214.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">4 De svenska hästarna lyser med sin frånvaro på Vincennes (13.55) denna onsdag där sadelloppet Prix Auguste Francois (€90.000) är höjdpunkten.<br>Det Grupp III-klassade loppet rids över 2.175 meter voltstart med 40.500 euro väntande på vinnaren och innehåller flera profilstarka namn såsom Franck Leblancs <strong>Freeman de Houelle</strong> (e. Vigove) och Charles Antoine Marys <strong>Florida Sport</strong> (e. Tornado Bello).<br>Den sistnämnda vann årets upplaga av Montéeliten på 1.09,8a/1.640 meter och är nu på jakt efter sin första seger sedan den 1 juli.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/06/floridasport-617x333.jpg" alt="" class="wp-image-310380"/><figcaption class="wp-element-caption">Florida Sport vid segern i Montéeliten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Svenskt finns det däremot i Amiens (16.32). Tomas Malmqvist prövar lyckan med en duo i form av <strong>Jorgio de Vandel</strong> (e. Ready Cash) i Prix Dame de Carreau (€19.000) samt <strong>Frozen Queen</strong> (e. Look de Star) i Prix Vismie (€25.000).<br>Båda hans hästar körs av Cédric Parys och Frozen Queen får även sällskap i Amiens av Ron Kuipers<strong> General du Nord</strong> (e. Un Mec d&#8217;Heripre), ägd av Stall Escapade.</p>



<p><strong>Så gick det för gårdagens svenskhopp på Vincennes:</strong><br><em>Hästnamn (far) – tränare – placering</em></p>



<ul class="wp-block-list">
<li>Orlando (e. Classic Photo) – Fredrik Wallin – 2:a – 10.000 euro</li>



<li>Ies Elisabet (e. Super Photo Kosmos) – Fredrik Wallin – 4:a – 3.200 euro</li>



<li>Icone de l&#8217;Etre (e. Brillantissime) – Fredrik Wallin – diskvalificerad</li>



<li>King Stallion (e. Ready Cash) – Tomas Malmqvist – diskvalificerad</li>
</ul>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2022-12-14/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5 När <strong>Borups Victory </strong>(e. Googoo Gaagaa) gjorde tävlingsdebut för Daniel Wäjersten blev det seger direkt.<br>Fyraåringen anförde hela vägen i gårdagens lunchlopp på Bergsåker och såg mycket stark ut vid målpassagen på 1.13,8a/2.140 meter.<br>En riktigt duglig tidsnotering då tävlingarna genomfördes i närmare 15 minusgrader.<br>– <em>Jag är jättenöjd. En fin häst som känts väldigt bra i träningen. Det här skönt att få ett bra kvitto</em>, sade Daniel Wäjersten i segerintervju på Sundsvallbanan.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/06/borupsvictory-1-617x333.jpg" alt="" class="wp-image-183191"/><figcaption class="wp-element-caption">Borups Victory var tidigare i träning hos Robert Bergh. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Droad AB äger den fyraåriga hingsten som nu står med sju segrar på 16 starter och 789.000 kronor i intjänade prispengar.<br>I Robert Berghs regi vann hästen ASVT Trottex Auktionslopp och hos Svante Båth räknade han hem Plåt-Svens Minne.</p>



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



<p class="has-drop-cap">6Björn Goop har fått 2019 års norska Oakstrea <strong>Sweet Lins</strong> (e. Orlando Vici) 1.11,5ak/515.529 kr i träning.<br>Samma år slutade stoet även sexa i finalen av Norskt Travkriterium för ston efter att vunnit ett uttagningslopp, men de efterföljande tre säsongerna har det blott blivit fyra segrar på 33 starter.</p>



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



<p class="has-drop-cap">7 Du missar väl inte möjligheten att köpa andel i något av Sulkysports V86-systemet?<br>I lördags räknade vi hem 35 femmor på ett av våra andelssystem vilket gav 19.950 kronor tillbaka och 1.330 kronor i vinst per andel.</p>



<p><em>Till kvällens V86-omgång finns nedanstående två alternativ att välja:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206233_V86_2022-12-14_40_1" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2022-12-14_40_1" target="_blank" rel="noreferrer noopener">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>

Fokustema
Morgonsvepet
Läs senare
Den som väntar på något gott…
Om årets mest emotsedda comeback, landets bästa tvååringar som tävlar på två olika banor samt om en Oakstrea som placerats hos Björn Goop går bland annat att läsa i dagens morgonsvep.
