
<p class="has-drop-cap wp-block-paragraph">Åby arrangerar veckans V75-omgång och det är god klass på tävlingarna. Gulddivisionsloppet Legolas Minne (V75-3) har förhöjt förstapris och där gör Elitloppsdeltagarna <strong>Ultion Face</strong> och <strong>Stoletheshow</strong> upp tillsammans med <strong>Four Guys Dream</strong> som vann ett försök till Sweden Cup och som kommer från fullträff i just högsta klassen.</p>



<p class="wp-block-paragraph">Spikarna hämtar vi dock från andra avdelningar. <strong>Need&#8217;em</strong> (V75-4) ska ha jättechans att leda hela vägen i Klass I-försöket då han är obesegrad från piken efter fyra försök.</p>



<p class="wp-block-paragraph">En effektiv spetshäst har även <strong>Luca Barosso</strong> (V75-2) visat sig vara. Han har drömläge i Klass II-försöket och vi tror inte att han blir passerad från den positionen i detta överkomliga sällskap.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/12/09v75.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2023/12/09v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Åby.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-12-09_6_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-12-09_6_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-12-09_6_5" data-type="link" data-id="https://www.atg.se/andelskungen/spel/206689_V75_2023-12-09_6_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Diamantstoet, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Filippa B.J.</strong> fick öppna tufft för ledningen senast i Silverdivisionen på Bergsåker och gick sig fullt naturligt trött på kuppen. Hon var riktigt bra som trea gången innan i Sto-SM och har haft en mycket bra säsong med dryga halvmiljonen intjänad även om det &#8221;bara&#8221; blivit tre segrar på dussinet försök. Oavsett om Jorma Kontio sänder henne till tät här och kör i den positionen eller väljer att släppa ledningen så kommer hon sitta bra till när det drar ihop sig.</li>



<li><strong>Mary Ann Lane </strong>slog ut i full blom i somras med en tredjeplats i Stochampionatet. Hon var även finalist i Derbystoet, men missade Breeders Crown. Någon fara med formen visade hon dock senast på Åby att det inte föreligger utan då stod hon för en mycket bra insats från bakspår mot äldre ston. Även om hon inte är någon startraket så har hon bra chans att sitta långt fram i fältet direkt från ett utsökt andraspår.</li>



<li><strong>Unleashed Kemp</strong> spurtade till snygg vinst från tillägg senast på Solvalla och fick äntligen vinna på svensk mark. Stoet gör karriärens sista start här då hon därefter ska flygas till USA för betäckning och utifrån det lär det knappast sparas på krutet bara man kommer ut i fritt läge.</li>



<li><strong>Ninja Zon</strong> stod för en strålande debut i André Eklundhs regi. Det var en insats som kom med ett stort utropstecken efter sig och vi håller henne som minst en outsider i det här loppet.</li>



<li><strong>Donna Summer</strong> har inte startat på drygt två månader och det är inte optimalt med skor för hennes del. På visad styrka och att hon stabiliserat sig rejält blir hon ändå ett tidigt bud.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5-2-1 <strong>B: </strong>7-3-9-6-8-11 <strong>C: </strong>10-4-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Filippa B.J. </strong>är raskast iväg, men frågan är om hon körs i ledningen nu över full väg? Vi tror att <strong>Mary Ann Lane </strong>kan hålla ut <strong>Carroty</strong> och överta i nästa skede om det ska släppas.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Luca Barosso </strong>stod för en stark insats under Åbergskvällen då han långspurtade berömvärt som tvåa bakom Mondriaan Boko. Han hamnade omöjligt långt bak i den efterföljande Klass II-starten i Mantorp och galopperade vid upploppets början då han var ute i vida spår och hade på tok för långt fram. Nu var hästen åter sig lik i senaste starten då han brottade ner Baywatch från dödens på ett övertygande vis och vi kan inte säga annat än att denna uppgift ser passande ut. Ur volten har han visat prov på god startsnabbhet och vi tror att valacken har god chans att spåra hela vägen.</li>



<li><strong>Rustico</strong> fick lägga en speed för att forceras till tät 1.500 meter före mål senast på Jägersro, men kunde likväl gå undan till en smått överlägsen seger. Femåringen ser ut att ha vaknat till liv ordentligt på senare tid och den här uppgiften är inte alls omöjlig för hans del även om det blir svårt att komma förbi Luca Barosso initialt.</li>



<li><strong>Rajon</strong> avslutade 1.11,3 sista 800 meterna lite i skymundan senast på Jägersro i en väl så tuff uppgift som han står inför denna gång. Från bakspår kommer det krävas en del klaff på bitarna för att han ska komma in i loppet, men vi tycker inte att han känns chanslös på något vis.</li>



<li><strong>Moira Boko </strong>hade ett svårt utgångsläge senast, men blev dugligt framdragen och kunde avgöra på ett plusbetonat vis i spurten. Den dagen mötte hon bara ston och här är det tveklöst något annat när det handlar om Klass II, lång distans och hingstar och valacker bland konkurrenterna.</li>



<li><strong>Vancouver High </strong>har lyft markant under hösten och får ses som loppets outsider från ett lämpligt åttondespår då han kan få rygg på Luca Barosso.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1 <strong>B: </strong>3-9-7-8-10-5 <strong>C: </strong>12-11-4-6-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Luca Barosso</strong> har frontat i sina voltstartslopp och ska ha toppchans att hålla ut <strong>Rustico</strong> initialt.</p>



<h2 class="wp-block-heading">Avd 3 – Gulddivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Ultion Face </strong>flög till tät senast i Gulddivisionen på Jägersro innan Adrian Kolgjini överlämnade taktpinnen till <strong>Four Guys Dream</strong>. Sjuåringen fick inte chansen förrän det var för sent och gick i mål med mycket sparade krafter. Vi påminner om hur formstark hästen var motsvarande period ifjol och här är chansen mycket god att han kan fronta, släppa till favoriten och sedan pröva lyckan via open stretch.</li>



<li><strong>Stoletheshow</strong> har haft en fin säsong med seger i Finlandia Ajo och finaldeltagande i Elitloppet som höjdpunkter. Han fick närmast en joggingtur senast på Bjerke då han släpptes till tät och kunde kontrollera loppet. Det är sannolikt att han får överta taktpinnen även denna gång, men däremot ställer vi oss lite frågande till om han är morsk nog att hålla emot Ultion Face om den sistnämnde får tassa med i rygg, spara speeden och utmana via open stretch.</li>



<li>Four Guys Dream släpptes till ledningen av Ultion Face senast och vann väldigt enkelt utan att behöva spela ut hela registret. Håkan K Perssons sjuåring har sett jättebra ut i sina två starter efter paus, men har en tendens att kunna tappa stilen efter hand när han startat på en period och vi behandlar honom med försiktighet denna gång från bakspår.</li>



<li><strong>Emoji</strong> har ingen seger i resultatraden, men likväl gjort starka insatser. Vi påminner om att han var tvåa bakom Four Guys Dream näst senast på 1.10,2.</li>



<li><strong>Beartime</strong> är van att tävla med skor på hovarna och får han spara speeden fram tills upploppet så kan det bita bra.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>B: </strong>7-8-10-4-3 <strong>C: </strong>2-6-1-12-9-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi tror att <strong>Ultion Face</strong> frontar och släpper man till <strong>Stoletheshow</strong> så är inte alls det fel för då får Ultion Face rena drömloppet bakom. När båda tävlar med skor kan vi se Ultion Face vara den bättre av dem.</p>



<h2 class="wp-block-heading">Avd 4 – Klass I, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Need&#8217;em</strong> såg jättefin ut vid spetssegern senast på Sundbyholm. Då som nu inledde han från spår tre bakom bilen och tog hand om ledningen med lätthet. Hästen är obesegrad från tät efter fyra försök och vi tror att den goda statistiken håller i sig även efter lördagens lopp.</li>



<li><strong>Hashtag Simoni</strong> stod för en toppinsats bakom Hustle Rain senast i S:T Leger på Åby. André Eklundhs häst har utvecklats på alla plan, men får svårt att hålla upp innerspår bakom bilen gentemot Need&#8217;em och det kan bli tufft att besegra den sistnämnde på speed.</li>



<li><strong>Soundtrack</strong> har funnit stilen i Tomas Malmqvists regi. Hästen segrade så nyligen som i lördags i Svensk Travsports Fyraåringsmonté och bevisade då att han kan prestera på en hög nivå med skor på hovarna. Sadelstarter kan slita på hästarna och nu när det blir täta lopp så får han stå tillbaka i vårt tips även om vi verkligen gillar grundkunnandet i denna Ready Cash-son.</li>



<li><strong>Global Delayed </strong>galopperade innan bilen släppte fältet senast som V75-favorit och vi fick aldrig se vad han kunde den dagen. Här tävlar fyraåringen med skor runt om för allra första gången då han kom ut utan bakskor redan i tävlingsdebuten och det står skrivet i stjärnorna hur det kommer påverka hans förmåga.</li>



<li><strong>Here&#8217;s Johnny Sox </strong>såg fin ut som fastlåst i vinnarhålet senast i ett Klass I-försök. Här tycker vi att konkurrensen är tuffare och startspåret är därtill klart sämre.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3-1-2-10 <strong>B: </strong>11-6-8-4-5 <strong>C: </strong>12-7-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Det kryllar inte av startblixtar i det här loppet utan <strong>Need&#8217;em </strong>ska ha toppchans att vinna starten.</p>



<h2 class="wp-block-heading">Avd 5 – Bronsdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Henrik Will </strong>galopperade bort fina pengar in mot upploppet i Dansk Travderby, men revanscherade sig i Ålborgs Stora Pris tre veckor senare. Den här hästen står tveklöst rimligt inne i gällande klass och såg fin ut i genrepet i Nyköbing Falster utan att att på något vis vara i maxform den dagen. Med loppet i kroppen går han säkert framåt och som sannolik ledare sitter han på trumf.</li>



<li><strong>The Baron </strong>har Olav Mikkelborg &#8221;skolat om&#8221; på senare tid. Senast svepte hästen runt sina konkurrenter från tredje utvändigt och bevisade ännu en gång att han inte alls är spetsberoende numera. Hamnar inte The Baron alltför långt bak i fältet denna gång så är han med och slåss om segern.</li>



<li><strong>Combat Fighter </strong>var inte på topp i senaste starten, men har annars gått väldigt bra under en längre period. På sin goda startsnabbhet kan han få en position långt fram i fältet direkt och då är han ett tidigt bud.</li>



<li><strong>Purple Rain </strong>var jättebra som tvåa bakom Mister F Daag i Hamburg den 3 oktober och står tveklöst rimligt inne i den här klassen. Det kan dock bli kämpigt att komma till från spår åtta och vi nöjer oss med att kategorisera honom som en outsider.</li>



<li><strong>Danao degli Dei </strong>började sin Sverigesejour med att vinna på 1.10,4a/1.640 meter från dödens, men därefter har det varit väldigt blandade resultat. De hästar från Alessandro Gocciadoros stall som blivit kvar i Sverige efter en tuff säsong med många krävande lopp har det inte slagit gnistor om och vi vill se leverans från Danao degli Dei innan han känns riktigt het för oss.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-9-7 <strong>B: </strong>8-2-10-1-3-4 <strong>C: </strong>11-5-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vårt tips bygger på att<strong> Henrik Will</strong> ska hålla ut <strong>Combat Fighter</strong>. <strong>Staro Peanut </strong>är inte heller oäven initialt, men vi tror inte man vill bråka och köra honom i tät i denna konkurrens.</p>



<h2 class="wp-block-heading">Avd 6 – Diamantstoet, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Sangria Pellini </strong>stod för en mycket rejäl 700 metersrepa vid segern på Jägersro i oktober och följde upp det med seger i enklare sällskap i Hamburg. Hon har inte vunnit sina fyra lopp av en tillfällighet i år utan är riktigt bra för sin klass och svårslagen de dagar hon löper upp till sitt yttersta kunnande.</li>



<li><strong>Jurista</strong> vann finalen av Norrlands Elitserie för treåringar ifjol, men gått segerlös genom årets sju starter. Bland dem finns finaldeltagande i Stochampionatet så säsongen har inte varit ett fiasko på något vis, men här gör hon i vilket fall småspännande debut i Marcus Schöns regi. Det återstår att se om han fått henne på rätt köl och har något spännande på gång för en Jurista som löper upp till sin högstanivå duger normalt sett väldigt bra i ett sådant här lopp.</li>



<li><strong>Rosemary Tile </strong>fick långt fram från sjätte utvändigt senast på Sundbyholm, men via duglig draghjälp på slutrundan avgjorde hon likväl loppet med tre längder som marginal. Det var en toppinsats och då stoet visade med eftertryck hur fint hon kan prestera på skor så känns hon som ett tidigt bud även här.</li>



<li><strong>Jane Hall </strong>tjänade drygt 300.000 kronor ifjol och har haft en aning svårt att bära de pengarna i år. Nu har hon gjort två starter i Flemming Jensens regi och antytt att formkurvan pekar uppåt så vi behandlar henne med viss respekt i det här loppet.</li>



<li><strong>Tasherit</strong> är segerlös i år, men tycks aldrig göra en dålig insats. Hon räds inte att tävla med skor på hovarna och tar många på segstyrka i slutskedet.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>8-9-12 <strong>B:</strong> 11-7-15-14-2-10-4-6 <strong>C: </strong>13-3-1-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Även om Thomas Uhrberg är en ypperlig startkusk får<strong> Kings Witch</strong> svårt att hålla ut<strong> Corona Park </strong>initialt.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Versace Face </strong>slog ihop och galopperade i samma ögonblick som startbilen släppte fältet senast på Jägersro. Hästen såg fin ut inför loppet och vi har ingen anledning att tro att det ska föreligga någon fara med formen. Versace Face står perfekt inne på pengarna i det här loppet, har två segrar på lika många försök under vinterperioden och är i ärlighetens namn inte ute i den allra värsta silvertillställningen.</li>



<li><strong>Even Steven </strong>fick nöta dödens vid senaste besöket på Åby och var stor i nederlaget. Han fick blott se sig besegrad av Hannibal Face som hade gått med i rygg och det var inget att säga något om utan han tog verkligen striden hela vägen in till mållinjen. Flemming Jensen väljer sina starthästar omsorgsfullt under vintermånaderna på svensk mark då det är skotvång och vi har ingen anledning att tro att han beger sig till Åby med en häst som inte ska klara av att tävla på skor.</li>



<li><strong>Bottnas Idol </strong>är van att tävla med just den nämnda balansen och det är en faktor som talar för honom här likså den häftiga styrka han bär på. För oss är Bottnas Idol en häst som bara blir bättre av att möta tuffare hästar eftersom det kan framkalla en annan typ av körning i loppen vi vill inte spela utan honom markerad på vårt system.</li>



<li><strong>Gaylord Am</strong> gjorde en bra insats på skor senast på Solvalla bakom High On Pepper utan att hota om segern. Sjuåringen har vunnit V75-lopp den här perioden, men det var i lägre klass och han har vissa problem om det blir för mycket speedkörning.</li>



<li><strong>Corazon Bar </strong>spurtade bra lite i skymundan i Halmstad. Även han har visat att han kan prestera med skor på hovarna och för oss är han åtminstone en outsider.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>4-6-2 <strong>B: </strong>12-11-3-1-7-8-9-5 <strong>C: </strong>10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi killgissar att Hans Crebas vill ha rygg med <strong>Gerben</strong> och då lär det bli strid mellan <strong>Versace Face </strong>och <strong>Even Steven</strong> om att få överta. Knapp fördel den förstnämnde.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 9 DECEMBER								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,2,3,5,6,7,8,9 (11,10)<br><strong>Avd 2:</strong> 1 Luca Barosso (3,9)<br><strong>Avd 3:</strong> 3,4,7,8,10 (2,6)<br><strong>Avd 4: </strong>3 Need&#8217;em (1,2)<br><strong>Avd 5: </strong>2,6,7,8,9 (10,1)<br><strong>Avd 6: </strong>7,8,9,11,12,14,15 (2,10)<br><strong>Avd 7: </strong>2,4,6 (12,11)</p>



<p class="wp-block-paragraph"><em>4.200 rader / 2.100 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
