
<p class="has-drop-cap wp-block-paragraph">1Snabb start till ledningen, men galopp efter 150 meter. Så inleddes senaste insatsen på tävlingsbanan för Gunnar Melanders stjärna<strong> Månlykke A.M.</strong> (e. Månprinsen A.M.) i Rättvik för tio dagar sedan. Upphämtningen var av bästa märke och visst har den flerfaldige svenske mästaren hittat formen igen under en säsong där han trots starka insatser i tuffaste konkurrens fortfarande väntar på första årssegern.</p>



<p class="wp-block-paragraph">När det är jackpot på V86 med 6,5 miljoner kronor extra i åttarättspotten i omgången som delas mellan Bergsåker (start 18.27) och Solvalla (start 18.15) blir Månlykke A.M. en av omgångens allra tyngsta favoriter. För motståndet står banemannen i Rättvik, Jan-Olov Persson-tränade <strong>Våler Nikolai </strong>(e. Åsajerven) och Marcus Lilius.</p>



<p class="wp-block-paragraph">Kvällens tyngsta favorittryck vilar annars på ett par som är vana vid det på huvudstadsbanan: Timo Nurmos-tränade <strong>Esposito</strong> (e. Villiam) med Magnus A Djuse i sulkyn. Esposito kvalade in till Svenskt Travderby i höstas, där han dock gick lottlös från finalen.</p>



<p class="wp-block-paragraph">Magnus A Djuse stormar fram mot sitt första kuskchampionat på landets största bana. Hans ledning är hela 16 segrar stor före Örjan Kihlström med fyra tävlingsdagar kvar av säsongen. Och Nurmos står i särklass bland tränarna både vad gäller segrar och prispengar till stallet.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/11/06v86.pdf" class="">Här kan du ta del av dagens startlistor till tävlingarna på Bergsåker och Solvalla.</a></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-12-06_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-12-06_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">2Loppet som ingen vill vinna – kan man kalla Vinterfavoriten för tvååringar för det? Faktum är att ingen vinnare av tvååringsloppet på Solvalla har gått vidare och vunnit Svenskt Travkriterium ett år senare.</p>



<p class="wp-block-paragraph">Den som det ställdes de största förhoppningarna till var 2005 års vinnare i Vinterfavoriten, Markku Nieminen-tränade <strong>Simb Chaplin </strong>(e. Pearsall Hanover), som inledde med 13 raka segrar innan han åkte på första förlusten i självaste Kriteriet. Där fick han nöja sig med tredjeplatsen bakom <strong>Marquis du Pommeau</strong> (e. General du Pommeau) och<strong> Staro Alive</strong> (e. Zoogin).</p>



<p class="wp-block-paragraph">Hans Ahlbins tvååringskung <strong>Tangens</strong> (e. Lep Hanover) vann – förstås – Vinterfavoriten med Stig H Johansson i vagnen och fanns på startlinjen i Kriteriet, där han slutade femma.</p>



<p class="wp-block-paragraph">Vinterfavoriten avgjordes i sju år, 1998-2004, i två avdelningar uppdelade efter kön, men har övriga år körts i ett enda lopp.</p>



<p class="wp-block-paragraph">Årets upplaga av Vinterfavoriten då? Ja, två namn sticker ut i kamp om 200.000 kronor i förstapris: tvåan i Svenskt Uppfödningslöpning<strong> Romulus Tooma</strong> (e. S.J.’s Caviar), som tränas av Diederik Meilink, och Fredrik Wallins Svampenvinnare <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar).</p>



<p class="wp-block-paragraph">Det väntar även ett större tvååringslopp på Bergsåker där 150.000 kronor väntar på vinnaren i Norrlands Elitseries final. Två av deltagarna i Svampen finns med även här: Daniel Wäjerstens <strong>Global Fearless</strong> (e. Booster Winner) och Mattias Djuses <strong>Pop the Cork </strong>(e. Perfect Spirit).</p>



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



<p class="has-drop-cap wp-block-paragraph">3Det är finaltätt på båda landets kvällsbanor denna onsdag. Finalen i International Stallions körsvensserie för kuskar födda 1988 eller senare avgörs på Bergsåker. Lila Gilljam vann grundserien och kvitterade ut en resa till Frankrike i samband med Prix d’Amérique i januari. En sådan resa ligger också i potten för vinnaren i kvällens lopp.</p>



<p class="wp-block-paragraph"><strong>Deltagare: </strong>Johan Brandel, Oskar Florhed, Lisa Gilljam, Niclas Hammarström Jill Ivarsson, Michelle Larsson, Ida Olsson, William Strand, Lukas Svedin, Öyvind Wagnild, Ludwig Wickman, Olle Wäjersten. Johan Brandel var inkvalad men missar finalen då bara elva hästar anmäldes.</p>



<p class="wp-block-paragraph">Två spännande fyraåringar dyker upp i startlistan i Oscar Berglunds <strong>Jackpot</strong> (e. Nunco), som varit bland de två bästa i åtta av tolv starter, samt Jan-Olov Perssons varmblod <strong>Zätamustangen</strong> (e. El Mago Pellini). Denne har hittat stilen i höst och ståtar med tre raka segrar.</p>



<p class="wp-block-paragraph">Bästa montéryttaren ska koras på Solvalla i montéfinalen, där tio ryttare gör upp i två lopp vardera. Landets ryttaretta Jonathan Carre sitter med trumf på hand som vinnare i grundserien, där placeringarna räknas som en avdelning i finalen. </p>



<p class="wp-block-paragraph">Carre rider bland annat Fredrik Wallins franske montéspecialist<strong> Ilie de Touchyvon</strong> (e. Bilibili), för sjätte gången. De fem första starterna har slutat med fyra segrar och ett andrapris!</p>



<p class="wp-block-paragraph"><strong>Deltagare: </strong>Jonathan Carre, Emilia Leo, Sofia Adolfsson, Christina A Hande, Agnes Larsson, Julia Andersson, Madelen Berås, Jennifer Persson, Anna Erixon, Nicole Melberg.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Det är gott om svenskintressen på Vincennes (första start kl. 13.55) denna onsdag.</p>



<p class="wp-block-paragraph">I det inledande Quinté-loppet Prix de Villers Cotterets (€53.000) tävlar fyra svensktränade hästar och ytterligare två svenskfödda dito.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2020/09/agoodpointhuv2.jpg" alt="" class="wp-image-112325"/><figcaption class="wp-element-caption">A Good Point. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholm ger Eric Raffin förtroende bakom <strong>Santos de Castella</strong> (e. Readly Express), David Thomain kör Preben Söviks Frankrikedebutant<strong> A Good Point</strong> (e. Maharajah), Paul Philippe Ploquin kuskar bakom Mattias Djuses <strong>Global Bookmaker </strong>(e. Broadway Hall), Romain Derieux bakom Björn Goops <strong>Frodo S. </strong>(e. Uniclove) och så tävlar den svenskfödda duon<strong> Mister Donald</strong> (e. Niky) och<strong> Easy Cash</strong> (e. Ready Cash) likaså i loppet som avgörs över 2.100 meter autostart med 23.850 euro i segerpremie.</p>



<p class="wp-block-paragraph">Två svenskfödda hästar tävlar därtill i evakueringsloppet Prix de Chinon (€40.000) då Pierre Levesque bidrar med <strong>Junkie</strong> (e. Varenne) och Vitale Ciotola startar <strong>Carbonfiber</strong> (e. Uncle Lasse) i detta montélopp över 2.850 meter voltstart där vinnaren får 18.000 euro.</p>



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



<ul class="wp-block-list">
<li><strong>Så gick det för gårdagens svenskhopp på Vincennes:</strong><br><em>Hästnamn (far) – Tränare – Placering – Prispengar</em></li>



<li><a href="https://sulkysport.se/skrallseger-for-malmqvist/" data-type="link" data-id="https://sulkysport.se/skrallseger-for-malmqvist/" target="_blank" rel="noreferrer noopener"><strong>Liza Josselyn </strong>(e. Love You) – Tomas Malmqvist – vinnare – 19.350 euro</a></li>



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



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



<p class="has-drop-cap wp-block-paragraph">5I Robert Berghs stall har det åter börjat trilla in nyförvärv med allt högre intensitet sedan han flyttade tillbaka till Åby.</p>



<p class="wp-block-paragraph">Ett av de senaste förvärven är femårige <strong>Uncle Silvio</strong> (e. Uncle Lasse) 1.11,3ak/363.800 kr som vann ett Klass II-försök på Jägersro under fjolårets derbyhelg i André Eklundhs regi, men som gått segerlös i dussinet starter därefter.</p>



<p class="wp-block-paragraph">Nu har alltså Åbyproffset tagit över valacken som även funnits i Thomas Uhrbergs och Camilla Janssons vård under den karriär som hittills resulterat i fyra segrar på 22 försök.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Blott 66 hästar tävlar i dagens åtta lunchlopp på Åby (första start kl. 12.20) vilket ger ett snitt på 8,25 deltagare per lopp.<br>Det begränsade intresset till trots går det finna en hel del intressanta namn i startlistorna.</p>



<p class="wp-block-paragraph">Mats Olssons <strong>Mr Weasley</strong> (e. S.J.&#8217;s Caviar) har inlett karriären med två raka segrar och ser ut att få bära på favoritskapet i ett småputtrigt treåringslopp som inleder lunchomgången.</p>



<p class="wp-block-paragraph">Jämngamle<strong> Furst Igor </strong>(e. Readly Express) tävlar i ett annat lopp för Per Nordström och kan rentav vara tävlingsdagens mest spännande häst.<br>Som tvååring vann valacken sin tävlingsdebut på 1.14,8/1.640 meter, men har därefter ägnat sig åt galopp i de övriga tre starterna och tvingats starta om efter att inte haft någon godkänd start på ett år.<br>Även i kvalet blev det galopp, men 1.17,0/2.140 meter som sluttid och idag är alltså Jägersrohästen redo att ta omtag.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/11/231206.pdf" target="_blank">Här kan du ta del av onsdagens startlistor.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Den femfaldiga Prix d&#8217;Amerique-deltagaren <strong>Delia du Pommereux</strong> (e. Niky) fick se sig regelrätt besegrad i tisdagskvällens snabblopp Prix Amiens Belgique (€6.000) i belgiska Mons.</p>



<p class="wp-block-paragraph">Tränaren Sylvain Roger satt själv upp bakom det tioåriga stoet som nådde ledningen, men tävlandes med skor på samtliga hovar var hon sig inte lik utan fick se sig regelrätt besegrad av Singalo-sonen <strong>Donovan Dark</strong>.<br>Den sistämnde vann loppet på 1.13,6a/1.750 meter i lag med Kristof Depuydt medan Delia du Pommereux kom i mål på 1.13,8 närmare följt av Henrik Hollstens svensktränade Bryssel (e. Ready Cash) som nöp tredjeplatsen på 1.13,9.</p>

Fokustema
Morgonsvepet
Läs senare
Första i elfte timmen?
Om en kallblodskung som ska försöka räta upp en krona som hamnat på sniskan, om "loppet som ingen vill vinna" och ett svensktätt Quinté-lopp på Vincennes går bland annat att läsa i onsdagens morgonsvep.
