a:39:{s:14:"__file_content";s:19:"alb-saved-templates";s:9:"Ausfluege";s:5107:"[av_section color='alternate_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Ausflüge mit dem Hotel am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class='' admin_preview_bg=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue809' font='entypo-fontello' title='Auf zum Phantasialand' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Bei uns können Sie das Phantasialand-Special buchen. <strong>Unser Angebot für Sie: </strong>1 Übernachtung im Doppelzimmer inklusive reichhaltigem Frühstücksbuffet und eine Tageskarte für das Phantasialand in Brühl.

Und natürlich gibt es bei uns auch noch mehr Ausflugsangebote. Sprechen Sie uns einfach an.

<a title="Freizeitpark Phantasialand" href="https://www.hotelamrhein.de/arrangements-angebote/freizeitpark-phantasialand/">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Afriika_Winter.jpg' attachment='3242' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/freizeitpark-phantasialand/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='86' font='entypo-fontello' title='Für Fahrradfahrer' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Bei uns sind Radfahrer jederzeit herzlich Willkommen. Unser Hotel liegt an den schönsten Fahrradstrecken in der Kölner Rheinregion.

Sie können Ihre Fahrräder bei uns sicher und kostenfrei unterstellen und für kleine Reperaturen steht Ihnen auch ein Werkzeug Set zur Verfügung.

<a title="Radfahr Special" href="https://www.hotelamrhein.de/?page_id=2560">Erfahren Sie mehr...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Bett_Bike-Logo2011_farbig_kleine_Darstellung_jpg.jpg' attachment='3175' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue83f' font='entypo-fontello' title='Kletterspaß und Abenteuer' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Einmal gemeinsam mit Ihrem Partner oder Gleichgesinnten die Wand hoch gehen.

Mit über 2600 Quadratmeter Kletterwand – indoor und outdoor – ist die BRONX Rock Kletterhalle die größte Indoor-Kletterhalle Deutschlands.

<a title="BronxRock – Kletterspaß" href="https://www.hotelamrhein.de/?page_id=2552">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/35691e81a4.jpg' attachment='3173' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/bronxrock-kletterspass/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue8ce' font='entypo-fontello' title='Kurzurlaub am Rhein' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Könnte es etwas schöneres geben als direkt am Rhein zu entspannen?

Genießen Sie das herrliche Panorama mit den vorbeiziehenden Schiffen und lassen Sie sich von der Gastfreundschaft am Rhein verwöhnen.

<a title="Kurzurlaub am Rhein" href="https://www.hotelamrhein.de/?page_id=2554">Mehr erfahren...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/kurzurlaub-am-rhein/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth]
[/av_section]";s:6:"Events";s:8964:"[av_section color='main_color' custom_bg='#f8f8f8' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_one_fourth first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/hotel_1.jpg' attachment='2698' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/feier.jpg' attachment='2726' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' align='center' animation='no-animation' link='' target='']

[/av_one_fourth][av_three_fourth]

[av_textblock ]
<h3>Events</h3>
<div>

Die Vorbereitung und Organisation eines Events bringt eine Menge Arbeit mit sich.

Bei einem Event geht es immer um die Story, welche  Sie erzählen möchten. Stellen Sie Emotionen in den Vordergrund.

Wir haben in unseren elf Jahren schon viele Geschichten gesehen und doch ist jede ein Unikat. Erzählen Sie Ihre Geschichte doch auch in unseren Räumlichkeiten.

Für Events, Incentives, Partys  finden Sie bei uns stets  ein erfahrenes Team zur Verfügung, welches Sie gerne bei der Planung, Abwicklung und Durchführung Ihrer Veranstaltung berät und unterstützt.

Legen Sie Ihre Wünsche in unsere Hände, denn die Konzeption, Organisation und Programmgestaltung sind unsere Stärke.

Bei Fragen und Wünschen stehen Ihnen Frau Hauke und Frau Kohnert gerne zur Seite und werden auch Ihre Veranstaltung zu einem einmaligen Erlebniss werden lassen.

Gerne vereinbaren wir einen Termin unter:
Telefon: 02236 325-0
Telafax:02236 325-199
oder E-Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

Nachfolgend finden Sie unsere Pauschalangebote, Buffetvorschläge und Getränkepauschalen. Natürlich kann auch jedes Angebot individuell erstellt werden!

</div>
[/av_textblock]

[/av_three_fourth]
[/av_section]

[av_section color='main_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading heading='Unsere Pauschalangebote' tag='h3' color='' custom_font='' style='blockquote modern-quote' size='' subheading_active='' subheading_size='15' padding='15'][/av_heading]

[av_one_half first]

[av_promobox button='no' label='Click me' link='manually,http://' link_target='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' size='large' icon_select='no' icon='ue800' font='entypo-fontello']
<b>Beispiel für eine Feier mit 35 Personen:</b>

Saal Berzdorf inkl. vorhandenen Mobiliar zur Saalmiete in Höhe von € 200,00.
Veranstaltungspauschale zu € 68,50 pro Person inklusive:
<ul>
	<li>Getränkepauschale „small“</li>
	<li>Buffet I</li>
	<li>sowie Service,</li>
	<li>Tanzfläche,</li>
	<li>Tischwäsche,</li>
	<li>Technik (Nutzung der vorhandenen Beschallungsanlage),</li>
	<li>Tischdekoration (kleines Blumenarrangement & Teelichthalter aus Glas),</li>
	<li>Menükarten</li>
</ul>
zuzüglich können Stuhlhussen in weiss à € 5,95 / Stk angemietet werden.
DJ inkl. Beschallungsanlage und Lichttechnik für die Tanzfläche ab € 595,00
Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_promobox]

[/av_one_half][av_one_half]

[av_promobox button='no' label='Click me' link='manually,http://' link_target='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' size='large' icon_select='no' icon='ue800' font='entypo-fontello']
<b>Beispiel für eine Feier mit 80 Personen:</b>

Saal Berzdorf inkl. vorhandenen Mobiliar ohne Saalmiete.
Veranstaltungspauschale zu € 78,00 pro Person inklusive:
<ul>
	<li>Getränkepauschale „medium“</li>
	<li>Buffet II</li>
	<li>sowie Service,</li>
	<li>Tanzfläche,</li>
	<li>Tischwäsche,</li>
	<li>Technik (Nutzung der vorhandenen Beschallungsanlage),</li>
	<li>Tischdekoration (kleines Blumenarrangement & Teelichthalter aus Glas),</li>
	<li>Menükarten</li>
</ul>
zuzüglich können Stuhlhussen in weiss à € 5,95 / Stk angemietet werden.
DJ inkl. Beschallungsanlage und Lichttechnik für die Tanzfläche ab € 595,00
Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_promobox]

[/av_one_half]
[/av_section]

[av_section color='main_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_one_fourth first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/feier.jpg' attachment='2726' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/hotel_1.jpg' attachment='2698' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' align='center' animation='no-animation' link='' target='']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/hotel_1.jpg' attachment='2698' align='center' animation='no-animation' link='' target='no']

[/av_one_fourth][av_three_fourth]

[av_heading tag='h3' padding='10' heading='Buffetideen & Getränkepauschalen' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15'][/av_heading]

[av_tab_container position='sidebar_tab sidebar_tab_left' boxed='border_tabs' initial='1']
[av_tab title='Buffet Standard' icon_select='yes' icon='ue812' font='entypo-fontello']
<b><i>Buffet</i></b>
Crêpes-Röllchen mit Lachs und Frischkäse gefüllt
Blattsalat der Saison mit zwei Dressing Paprika und Champignons gefüllt mit Frischkäse
Getrocknete Tomaten
***
Brot & Butter, Kräuterbutter
Soßen

<b><i>Warm
</i></b>Medaillon vom Schweinefilet im Speckmantel, Pfeffersauce
Rosmarinkartoffeln
Bohnen, glasierte Möhren
Hähnchenbrust auf Schmorgemüse
Weiße Nudeln

<b><i>Dessert</i></b>
Obstspieße „mediterran“
Vanillesauce
Joghurtcreme mit Himbeermark
[/av_tab]
[av_tab title='Buffet Premium' icon_select='yes' icon='ue812' font='entypo-fontello']
<b><i>Buffet</i></b>
Lachs gebeizt, Garnelensalat mit Wurzelgemüse
Puten-Tonnato mit Kapernäpfeln
Anti-Pasti:
Getrocknete Tomaten, Zucchini, marinierte Champignons
Oliven, Tomate-Mozzarella-Spieße
Raukesalat mit Pinienkernen und Parmesan
Balsamico-Dressing
Parmaschinken an mariniertem grünen Spargel
***
Brot & Butter, Soßen

<b><i>Warm
</i></b>Lammragout „Toscana“
Kartoffelgratin
Hähnchenbrust „Sizilianisch“ auf Blattspinat
Rosmarinkartoffeln
Streifen vom Salmfilet auf Wurzelgemüse, Zitronengrassauce
Weiße Nudeln

<b><i>Dessert</i></b>
Tiramisu-Schnitte
Obstsalat

Käseauswahl
Brot & Butter
[/av_tab]
[av_tab title='Getränkepauschale „small“' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Reissdorf-Kölsch</li>
	<li>Krombacher Pils</li>
	<li>1 Rotwein (Hauswein)</li>
	<li>1 Weisswein (Hauswein)</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle)</li>
	<li>Selters Mineralwasser</li>
	<li>Espresso, Café crema, Cappuccino</li>
</ul>
Ab € 29,50 pro Person *
[/av_tab]
[av_tab title='Getränkepauschale “medium”' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Sekt & O-Saft oder Sprizz/Hugo zum Empfang</li>
	<li>1 Rotwein (Auswahl aus 2 Hausweinen)</li>
	<li>1 Weisswein (Auswahl aus 2 Hausweinen)</li>
	<li>Reissdorf-Kölsch</li>
	<li>Krombacher Pils & Pils alkoholfrei</li>
	<li>Krombacher Weizen & Weizen alkoholfrei</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle)</li>
	<li>Selters Mineralwasser</li>
	<li>Kaffeespezialitäten</li>
</ul>
Ab € 36,00 pro Person *
[/av_tab]
[av_tab title='Getränkepauschale “premium”' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Champagner & Cocktail (z. B. Caipirinha, Mojito,Tequilla Sunrise, Pina Colada)</li>
	<li>2 Rotweine (Auswahl aus verschiedenen Sorten unseres Weinangebotes)</li>
	<li>2 Weissweine (Auswahl aus verschiedenen Sorten unseres Weinangebotes)</li>
	<li>1 Roséwein (Hauswein)</li>
	<li>Reissdorf-Kölsch, Reissdorf-Kölsch alkoholfrei</li>
	<li>Krombacher Pils & Pils alkoholfrei</li>
	<li>Krombacher Weizen & Weizen alkoholfrei</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle, Bitter Lemon, Ginger Ale, Tonic Water)</li>
	<li>Selters Mineralwasser</li>
	<li>Kaffeespezialitäten</li>
	<li>1 Digestif pro Person (z. B. Jubiläumsaquavit oder Linie, Williams Birne, Grappa, Korn, Ramazzotti)</li>
</ul>
Ab € 41,50 pro Person *
[/av_tab]
[/av_tab_container]

[av_textblock]
* Verlängerungsstunde: € 5,00 pro Person
Selbstverständlich können alle Getränke auch nach Verbrauch berechnet werden. Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_textblock]

[/av_three_fourth]
[/av_section]";s:16:"Freizeitprogramm";s:18801:"[av_fullscreen size='extra_large' image_attachment='' animation='slide' autoplay='false' interval='5' control_layout='av-control-hidden' scroll_down='aviaTBscroll_down']
[av_fullscreen_slide slide_type='image' id='5742' position='top center' video='http://' mobile_image='' video_cover='' title='Freizeitprogramm' custom_title_size='' custom_content_size='' caption_pos='caption_bottom caption_bottom_framed caption_framed' link_apply='' link='lightbox' link_target='' button_label='Click me' button_color='light' link1='manually,http://' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='']
Genießen Sie Ihren Aufenthalt, auch rund um das Hotel am Rhein.
[/av_fullscreen_slide]
[/av_fullscreen]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='sektion-phantasialand' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/03/Phantasialand-Black-Mamba_01.jpg' attachment='5489' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Auf zum Phantasialand!' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<section class="av_textblock_section ">
<div class="avia_textblock ">

Abenteuer erleben im Phantasialand und übernachten im Hotel am Rhein inklusive reichhaltigem Frühstücksbuffet.

Unsere Pakete beinhalten jeweils:
<ul>
 	<li>1 Übernachtung in der jeweiligen Zimmerkategorie Komfort</li>
 	<li>Reichhaltiges Frühstücksbuffet</li>
 	<li>1 Eintritts-/Tageskarte für das Phantasialand Brühl je Person</li>
</ul>
Paketpreis ab 122,50 €

</div>
</section>
[/av_textblock]

[av_button label='Phantasialand-Paket buchen' link='page,3993' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_three_fifth][av_one_third first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Einzelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']122,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']1 Erwachsener[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='page,3993' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Doppelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']180,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']2 Erwachsene[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='page,3993' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Familienzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']298,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']2 Erwachsene und 2 Kinder[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='page,3993' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]

[/av_one_third]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='sektion-radstation-koeln' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/fahrradtour_rhein.jpg' attachment='5741' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_three_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Das Rheinland mit dem Rad erkunden' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
In Kooperation mit der <a href="https://www.radstationkoeln.de/" target="_blank" rel="noopener">Radstation Köln</a> bieten wir Ihnen qualitativ hochwertige City-Bikes zu fairen Preisen.

Die Radstation Köln (zentral gelegen am Kölner Hauptbahnhof) bietet Ihnen Mountainbikes, Trekkingräder, Tandems, Kinderräder, E-Bikes und Fahrzeuge zur Behindertenmobilität.

Fragen Sie an unserer Rezeption nach dem Fahrradverleih.
[/av_textblock]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Radstation-Köln-ohne-Hbf.jpg' attachment='3856' attachment_size='full' align='center' styling='' hover='' link='manually,https://www.radstationkoeln.de/' target='_blank' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' admin_preview_bg=''][/av_image]

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='sektion-rheinschifffahrt' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/rheinschifffahrt.jpg' attachment='5746' attachment_size='full' attach='parallax' position='bottom center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading heading='Schiffstouren auf dem Rhein' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='5' color='' custom_font='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
Direkt vor der Haustür: Die <a href="http://www.kd-rheinschiffahrt.de/" target="_blank" rel="noopener">Köln-Düsseldorfer Deutsche Rheinschifffahrt AG</a> bietet eine Anlegestelle direkt am Hotel am Rhein gelegen.
[/av_textblock]

[/av_two_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_three_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='sektion-bronxrock' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/kletterhalle.jpg' attachment='5745' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Für alle, die hoch hinaus wollen' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>
<ul>
 	<li>1 Übernachtung im Doppel- oder Einzelzimmer</li>
 	<li>inklusive reichhaltigem Frühstücksbuffet</li>
 	<li>sowie einen Sportkletterkurs in der Bronx Rock Kletterhalle</li>
</ul>
Einmal gemeinsam mit Ihrem Partner oder Gleichgesinnten die Wand hoch gehen. Mit über 2600 Quadratmeter Kletterwand – indoor und outdoor – ist die BRONX Rock Kletterhalle die größte Indoor-Kletterhalle Deutschlands. 300 abwechslungsreiche Kletter-Routen, kombiniert mit einem innovativen Raumkonzept, sorgen für „Klettern auf höchstem Niveau“. Enthalten sind: Ganztageseintritt, Leihgebühren für Equipment, 1,5 stündige Trainerbetreuung, anschließend freies Klettern.

<strong>Preise auf Anfrage</strong>

</div>
[/av_textblock]

[av_button label='Verfügbarkeit erfragen' link='page,2342' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_one_half]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='sektion-kartcenter-cologne' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/kartcenter.jpg' attachment='5744' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Formel 1 Feeling in Köln' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>

Unser Indoor-Carting Angebot für Sie:
<ul>
 	<li>"Auftanken" mit einem Begrüßungsdrink in unserer Rhein Bar</li>
</ul>
<ul>
 	<li>Gas geben im Kartcenter Cologne</li>
</ul>
<ul>
 	<li>Fahrerbesprechung und Einweisung</li>
</ul>
Zurück im Hotel am Rhein haben Sie Ihr Ziel erreicht:

Übernachtung inklusive reichhaltigem Frühstücksbüffet (<strong>Preise auf Anfrage</strong>)

* Buchbarkeit ab Personen, Angebot gültig nach Verfügbarkeit

</div>
[/av_textblock]

[av_button label='Verfügbarkeit erfragen' link='page,2342' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_three_fifth]
[/av_section]";s:7:"Galerie";s:303:"[av_one_half]
[av_gallery ids='2925,2927,3454,2928,2935,2940,2930,3456,2932,2933,2941,3457,3583,3584,3585' style='big_thumb' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='thumbnail' columns='6' imagelink='lightbox' lazyload='avia_lazyload']
[/av_one_half]";s:22:"Hotel und Preisangebot";s:5300:"[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' scroll_down='' id='' color='main_color' custom_bg='' src='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' video_mobile_disabled='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_masonry_gallery ids='2760,2925,2928,2966' items='4' columns='2' paginate='pagination' size='fixed masonry' gap='large' overlay_fx='' container_links='active' id='' caption_elements='none' caption_styling='' caption_display='on-hover']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_heading tag='h3' padding='10' heading='Comfort direkt am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
Unsere 68 großen, hell und modern eingerichteten Einzelzimmer, Doppelzimmer und Suiten in Wesseling bieten hohen Komfort und Behaglichkeit. Neben unseren Komfort-Zimmern stehen Ihnen Superior-Zimmer mit Rheinblick und Wasserkocher zur Kaffee- und Teezubereitung sowie 2 Juniorsuiten, 3 Familiensuiten und eine Rheinblicksuite je nach Verfügbarkeit zur Verfügung.

Unvergesslich bleibt der Blick auf den Rhein, den Sie vom größten Teil der Zimmer, der Lobby-Bar und dem Frühstücksraum aus haben.

Haustiere sind bei uns jederzeit Willkommen.

<strong>Unsere Pakete beinhalten jeweils: </strong>
<ul>
	<li>1 Übernachtung in der jeweiligen Zimmerkategorie Komfort</li>
	<li>Reichhaltiges Frühstücksbuffet</li>
	<li>1 Eintritts-/Tageskarte für das Phantasialand Brühl je Person</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_default' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Einzelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']119 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']1 Erwachsener[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='Jetzt buchen' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' link_target='' size='large' position='center' icon_select='no' icon='ue800' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff']

[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_default' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Doppelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']173 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']2 Erwachsene[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='Jetzt buchen' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' link_target='' size='large' position='center' icon_select='no' icon='ue800' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff']

[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_default' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Familienzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']275 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']2 Erwachsene und 2 Kinder[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='Jetzt buchen' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' link_target='' size='large' position='center' icon_select='no' icon='ue800' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff']

[/av_cell][/av_row]
[/av_table]

[/av_one_third]
[/av_section]";s:9:"Icon-List";s:1750:"[av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']
[av_heading tag='h3' padding='10' heading='Wir bieten Ihnen:' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' custom_content_size='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
[av_iconlist_item title='Nichtraucher-Hotel' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello']
Seit dem 01.12.2014 stellen wir ausschließlich Nichtraucher-Zimmer zur Verfügung.
[/av_iconlist_item]
[av_iconlist_item title='Highspeed-Internet' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello']
Genießen Sie eine Übertragungsgeschwindkeit von bis zu 100 Mbit/s.
[/av_iconlist_item]
[av_iconlist_item title='Für Frühaufsteher und Langschläfer' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello']
Anreise (Check-In): ab 14:00 Uhr
Abreise (Check-out): bis 11:00 Uhr
[/av_iconlist_item]
[/av_iconlist]
[/av_one_third]";s:14:"JR-Cocktailbox";s:2588:"[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='sektion-cocktail-box' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/03/cocktail-box.jpg' attachment='5654' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_one_half first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading heading='Cocktail-Box' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='10' color='' custom_font='#ffffff' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg=''][/av_heading]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<h4>Wandelbar | Individuell | Einzigartig</h4>
<ul>
 	<li>Die Cocktailmaschine für perfekte Cocktails</li>
 	<li>Servierfertig in Sekunden</li>
 	<li>Frisch gemixt für besten Geschmack</li>
 	<li>Hohe, gleichbleibende Qualität</li>
 	<li>Bis zu 500 Cocktails in der Stunde</li>
</ul>
<a href="http://www.cocktail-box.com" target="_blank" rel="noopener"><img class="alignleft wp-image-5652 size-medium" src="https://www.hotelamrhein.de/wp-content/uploads/2018/03/image001-300x80.jpg" alt="" width="300" height="80" /></a>
[/av_textblock]

[av_button label='cocktail-box bei uns buchen!' link='manually,http://www.cocktail-box.com' link_target='_blank' size='x-large' position='left' icon_select='yes' icon='ue897' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_one_half]
[/av_section]";s:21:"JR-Cocktailbox-Teaser";s:1681:"[av_one_half first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']
[av_heading heading='Cocktail-Box' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='10' color='' custom_font='#ffffff' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg=''][/av_heading]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<h4>Wandelbar | Individuell | Einzigartig</h4>
<ul>
 	<li>Die Cocktailmaschine für perfekte Cocktails</li>
 	<li>Servierfertig in Sekunden</li>
 	<li>Frisch gemixt für besten Geschmack</li>
 	<li>Hohe, gleichbleibende Qualität</li>
 	<li>Bis zu 500 Cocktails in der Stunde</li>
</ul>
<a href="http://www.cocktail-box.com" target="_blank" rel="noopener"><img class="alignleft wp-image-5652 size-medium" src="https://www.hotelamrhein.de/wp-content/uploads/2018/03/image001-300x80.jpg" alt="" width="300" height="80" /></a>
[/av_textblock]

[av_button label='cocktail-box bei uns buchen!' link='manually,http://www.cocktail-box.com' link_target='_blank' size='x-large' position='left' icon_select='yes' icon='ue897' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']
[/av_one_half]";s:14:"JR - Iconliste";s:1758:"[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h3' padding='10' heading='Wir bieten Ihnen:' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' custom_content_size='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
[av_iconlist_item title='Nichtraucher-Hotel' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello']
Seit dem 01.12.2014 stellen wir ausschließlich Nichtraucher-Zimmer zur Verfügung.
[/av_iconlist_item]
[av_iconlist_item title='Highspeed-Internet' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello']
Genießen Sie eine Übertragungsgeschwindkeit von bis zu 100 Mbit/s.
[/av_iconlist_item]
[av_iconlist_item title='Für Frühaufsteher und Langschläfer' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello']
Anreise (Check-In): ab 14:00 Uhr
Abreise (Check-out): bis 11:00 Uhr
[/av_iconlist_item]
[/av_iconlist]

[/av_one_third]";s:20:"JR - Kontaktformular";s:528:"[av_contact email='info@hotelamrhein.de' button='Senden' title='Senden Sie uns eine Nachricht' sent='Ihre Nachricht wurde versendet!' subject='' autorespond='' captcha='active']
[av_contact_field label='Name' type='text' options='' check='is_empty' width='']
[av_contact_field label='Email' type='text' options='' check='is_email' width='']
[av_contact_field label='Betreff' type='text' options='' check='is_empty' width='']
[av_contact_field label='Nachricht' type='textarea' options='' check='is_empty' width='']
[/av_contact]";s:29:"JR - Reiter Tagungspauschalen";s:2711:"[av_tab_container position='top_tab' boxed='border_tabs' initial='1']
[av_tab title='Tagungspauschale Rheintal' icon_select='no' icon='ue800' font='entypo-fontello']
<div>
<ul>
 	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl, frischem Obst, Joghurt und kleinen Snacks</li>
 	<li>Mittagsimbiss (belegte Brötchen und Suppe)</li>
 	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl und herzhaften und süßen Snacks</li>
 	<li>Standardtechnik (Flipchart, Pinwand, Leinwand)</li>
 	<li>Selters Mineralwasser im Tagungsraum</li>
</ul>
€ 39,00 pro Person/Tag

</div>
[/av_tab]
[av_tab title='Tagungspauschale Rheinberg' icon_select='no' icon='ue800' font='entypo-fontello']
<ul>
 	<li>Tagungsraum mit Tageslicht entsprechend der Teilnehmerzahl</li>
 	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl, frischem Obst, Joghurt und kleinen Snacks</li>
 	<li>Mittagessen (Lunch-Buffet) inklusive Selters Mineralwasser</li>
 	<li>Kaffeepause mit Kaffeespezialitäten, Tee und herzhaften und süßen Snacks</li>
 	<li>Standardtechnik (Flipchart, Pinwand, Leinwand)</li>
 	<li>Tagungsgetränke (Softdrinks, Selters, Kaffee, Tee) im Tagungsraum</li>
 	<li>Parkplatz direkt vor der Tür</li>
</ul>
€ 58,00 pro Person/Tag
[/av_tab]
[av_tab title='Tagungspauschale "Live & Experience"' icon_select='no' icon='ue800' font='entypo-fontello']
<div>

<strong>Unser LIVE & EXPERIENCE Angebot für Sie:</strong>

</div>
<ul>
 	<li>Tagungsraum mit Tageslicht entsprechend der Teilnehmerzahl</li>
 	<li>1 Übernachtung im Einzel- oder Doppelzimmer inklusive reichhaltigem Frühstücksbuffet</li>
 	<li>Kaffeepause mit mit Kaffeespezialitäten, Teeauswahl, frischem Obst, Joghurt und kleinen Snacks</li>
 	<li>Mittagessen (Lunch-Buffet) inklusive Selters Mineralwasser</li>
 	<li>Standardtechnik (Flipchart, Pinwand, Leinwand)</li>
 	<li>Selters Mineralwasser im Tagungsraum</li>
</ul>
<strong>Teamkletterevent in der BRONX ROCK Kletterhalle.</strong>

Unter professioneller Leitung durch ausgebildete Klettertrainer erleben Sie gemeinsam mit Ihrem Team in Deutschlands größter Kletterhalle eine Teamgeist stärkende Veranstaltung. Nach einer sicherheitstechnischen Klettereinweisung warten zwei unterschiedliche Aufgaben auf Sie. Nur gute Kommunikation, gegenseitiges Vertrauen und eine gemeinsame Strategie führen zum Ziel. Die Übungen werden auf Ihr Team abgestimmt, damit auch die nicht so sportlichen Teilnehmer an dem Teamevent teilnehmen können. (Dauer ca. 3 Stunden)

Buchbar auf Anfrage ab 10 Personen (nach Verfügbarkeit). Bei einem gemeinsamen Abendessen können Sie bei uns im Hotel und später in der Rheinbar oder Terrasse am Rhein den Tag entspannt ausklingen lassen.
[/av_tab]
[/av_tab_container]";s:25:"JR - Reiter Teambuildings";s:3918:"[av_tab_container position='top_tab' boxed='border_tabs' initial='1']
[av_tab title='Teambuilding MusicWorks' icon_select='no' icon='ue800' font='entypo-fontello']
<section class="av_textblock_section ">
<div class="avia_textblock  ">

<strong>Kurzportrait</strong>
Der interaktive Drum Circle und die Cajon-Werkstatt bringen neue Energie in ein Team und erzeugen ein starkes Gemeinschaftserlebnis mit Spaß, Erfolg und Stressabbau.
Die Praxis zeigt, das Trommeln und Musikworkshops die Kreativität fördern, inspirieren und einen nachhaltigen Lerneffekt haben. Der Teamgeist, die Motivation und der Dialog in Gruppen und Unternehmen werden verbessert.

<strong>Programmbeschreibung</strong>
Beim Drum Circle schwingt sich das Team rhythmisch mit afrikanischen Trommeln ein. Es entsteht ein einzigartiges Gemeinschaftsgefühl, in der die Teilnehmer Stärkung und Freude erleben. In der Cajon-Werkstatt geht es darum, eine eigene Cajon anzufertigen, die der Teilnehmer auch behalten darf. Im Anschluss daran lernt der Teilnehmer die Cajon-typische Spielweise in einer gemeinsamen Trommelaktion mit dem Team kennen.

<strong>Unsere Leistungen</strong>
<ul>
 	<li>Planung und Vorbereitung</li>
 	<li>Ausrüstung und Material inkl. Auf- und Abbau</li>
 	<li>Betreuung durch erfahrene Musiker (Projektleiter vor Ort)</li>
</ul>
</div>
</section>
[/av_tab]
[av_tab title='Teambuilding TasteWorks' icon_select='no' icon='ue800' font='entypo-fontello']
<section class="av_textblock_section ">
<div class="avia_textblock  ">

<strong>Kurzportrait</strong>
Nachdem bei der Tagung besonders die Sinne SEHEN und HÖREN angesprochen wurden, wird am Nachmittag besonders der Geschmackssinn angeregt.
An verschiedenen Genuss-Stationen werden Wein probiert, Schokolade auf der Zunge geschmolzen, an Kräutern genascht, Säfte erraten, Kaffeesorten vorgestellt und kölsche Spezialitäten zubereitet.

<strong>Programmbeschreibung</strong>
In Teams aufgeteilt durchläuft man verschiedene Genuss-Stationen, an denen man aktiv Genuss-Wissen über unterschiedliche Köstlichkeiten erfährt. Die Sommeliers und Profis in ihrem Gebiet stehen dabei Rede und Antwort und geben Ihnen den ein oder anderen wertvollen Tipp. Ob beim Wein- oder Kaffeetasting, bei der Wahl nach der individuell passenden Schokolade oder beim Erraten von Kräutern und Säften. Schärfen Sie Ihre Sinne!

<strong>Unsere Leistungen</strong>
<ul>
 	<li>Planung und Vorbereitung</li>
 	<li>Ausrüstung und Material inkl. Auf- und Abbau</li>
 	<li>Betreuung durch erfahrene Sommeliers und Profis</li>
 	<li>Projektleiter vor Ort</li>
 	<li>Kleines Give-away</li>
</ul>
</div>
</section>
[/av_tab]
[av_tab title='Teambuilding TeamWorks' icon_select='no' icon='ue800' font='entypo-fontello']
<section class="av_textblock_section ">
<div class="avia_textblock  ">

<strong>Kurzportrait</strong>
Als Ausgleich zur Tagung am Vormittag werden die Teilnehmer am Nachmittag mit einer sportlichen Team-Trophy gefordert. Aufgebaut wird ein Parcours mit verschiedenen Stationen. Mehrere Teams werden gebildet, die in verschiedenen Disziplinen gegeneinander antreten. Mit einer Teamkarte sammeln die Teams Punkte, so dass am Ende ein Sieger-Team gekürt wird.

<strong>Programmbeschreibung</strong>
Jedes Team beginnt mit einer anderen Station, die jeweils von einem Instruktor besetzt ist. Mögliche Stationen sind ein Segway-Parcours, ein sportlich-aktiver Human-Kicker, das verzwickte Weinflaschen-Spiel, Torwandschießen oder Montagsmaler mit dem Riesen-Stift. Alle angebotenen Programme sind sowohl Indoor im Rheinforum als auch Outdoor vor der Location realisierbar.

<strong> Unsere Leistungen</strong>
<ul>
 	<li>Planung und Vorbereitung</li>
 	<li>Ausrüstung und Material inkl. Auf- und Abbau</li>
 	<li>Betreuung durch erfahrene Instruktoren</li>
 	<li>Projektleiter vor Ort</li>
 	<li>Preis für Gewinnerteam</li>
</ul>
</div>
</section>
[/av_tab]
[/av_tab_container]";s:14:"JR - Separator";s:296:"[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']";s:20:"JR - Standard-Button";s:226:"[av_button label='Unsere Zimmer' link='page,4933' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']";s:12:"JR - Tabelle";s:1026:"[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']
[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Einzelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']121,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']1 Erwachsener[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='page,3993' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]
[/av_one_third]";s:14:"JR - Textblock";s:2087:"[av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']
[av_heading tag='h2' padding='5' heading='Für alle, die hoch hinaus wollen' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>
<ul>
 	<li>1 Übernachtung im Doppel- oder Einzelzimmer</li>
 	<li>inklusive reichhaltigem Frühstücksbuffet</li>
 	<li>sowie einen Sportkletterkurs in der Bronx Rock Kletterhalle</li>
</ul>
Einmal gemeinsam mit Ihrem Partner oder Gleichgesinnten die Wand hoch gehen. Mit über 2600 Quadratmeter Kletterwand – indoor und outdoor – ist die BRONX Rock Kletterhalle die größte Indoor-Kletterhalle Deutschlands. 300 abwechslungsreiche Kletter-Routen, kombiniert mit einem innovativen Raumkonzept, sorgen für „Klettern auf höchstem Niveau“. Enthalten sind: Ganztageseintritt, Leihgebühren für Equipment, 1,5 stündige Trainerbetreuung, anschließend freies Klettern.

<strong>Buchbar ist dieses Arrangement am Wochenende zum Preis von </strong>
<ul>
 	<li>68,50 € pro Person im Doppelzimmer</li>
 	<li>97,00 € pro Person im Einzelzimmer</li>
</ul>
</div>
[/av_textblock]

[av_button label='Verfügbarkeit erfragen' link='page,2342' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']
[/av_one_half]";s:26:"JR - Textblock mit Galerie";s:1396:"[av_two_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']
[av_heading tag='h3' padding='10' heading='Komfort und Behaglichkeit im Hotel am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
Ob Einzelzimmer, Doppelzimmer oder Familienzimmer... Das Hotel am Rhein ist familien- und haustierfreundlich und hat mit seinen 68 Zimmern etwas für jeden Geschmack.
[/av_textblock]

[av_masonry_gallery ids='2925,2928,2966,3454' items='4' columns='2' paginate='pagination' size='fixed masonry' orientation='' gap='large' overlay_fx='' container_links='active' id='' caption_elements='none' caption_styling='' caption_display='on-hover' color='' custom_bg='' av-medium-columns='' av-small-columns='' av-mini-columns='']
[/av_two_third]";s:17:"JR_Fullsize-Image";s:1065:"[av_fullscreen size='extra_large' image_attachment='' animation='slide' autoplay='false' interval='5' control_layout='av-control-hidden' scroll_down='aviaTBscroll_down']
[av_fullscreen_slide slide_type='image' id='5184' position='top left' video='http://' mobile_image='' video_cover='' title='Herzlich Willkommen im Hotel am Rhein' custom_title_size='' custom_content_size='' caption_pos='caption_bottom caption_bottom_framed caption_framed' link_apply='' link='lightbox' link_target='' button_label='Click me' button_color='light' link1='manually,http://' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' video_controls='' video_mute='' video_loop='' video_autoplay='' overlay_enable=''][/av_fullscreen_slide]
[/av_fullscreen]";s:19:"kd-schiffstouren001";s:4774:"[av_section min_height='custom' min_height_px='700' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' scroll_down='aviaTBscroll_down' custom_arrow_bg='' id='sektion-phantasialand' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://www.hotelamrhein.de/wp-content/uploads/2019/06/KD-Schifffahrt-Hotel-am-Rhein-001.jpg' attachment='6180' attachment_size='full' attach='parallax' position='center center' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-2y7dla5']
[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-11bslp']

[av_heading heading='KD Schiffstouren | Kombiarrangement im Siebengebirge' tag='h2' link_apply='' link='manually,http://' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-nx8n'][/av_heading]

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jub7k40s' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-2s60g19' admin_preview_bg='']
Fahren Sie mit der KD direkt von Wesseling zum sagenumwobenen Drachenfels nach Königswinter.

Neben den landschaftlichen Höhepunkten erwartet Sie dort mit dem Sea Life Königswinter eine ganz besondere Freizeitattraktion. Alternativ können Sie den Drachenfels mit der Drachenfelsbahn erkunden. Die Berg- und Talfahrt ist im KD Kombiticket inkludiert.

<strong>Das KD Kombiticket beinhaltet:</strong>
<ul>
 	<li>eine Übernachtung im Doppelzimmer Superior</li>
 	<li>reichhaltiges Frühstücksbuffet</li>
 	<li>die Hin- und Rückfahrt mit dem Schiff</li>
 	<li>und wahlweise den Eintritt ins Sea Life oder die Fahrt mit der Drachenfelsbahn.</li>
</ul>
[/av_textblock]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-2wq883x']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-pw80mf'][av_cell col_style='' av_uid='av-o10luv']KD Kombiticket pro Person[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-muett3'][av_cell col_style='' av_uid='av-kisa6f']78,00 €[/av_cell][/av_row]
[av_row row_style='' av_uid='av-iwyvmf'][av_cell col_style='' av_uid='av-hszu2f']1 Übernachtung im Doppelzimmer Superior
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-5gw3b'][av_cell col_style='' av_uid='av-eg9rqf']Reichhaltiges Frühstücksbuffet[/av_cell][/av_row]
[av_row row_style='' av_uid='av-c7b16f'][av_cell col_style='' av_uid='av-ao509j']wahlweise 1 Eintrittskarte ins Sea Life oder für eine Fahrt mit der Drachenfelsbahn[/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-yk4pj'][av_cell col_style='' av_uid='av-76eh0n'][av_button label='JETZT ANFRAGEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/kd-schiffstouren/#buchung' link_target='' size='large' position='center' label_display='' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-nhguv'][av_cell col_style='' av_uid='av-3lm75j']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_two_fifth]
[/av_section]";s:23:"KD Schiffstouren Archiv";s:20185:"[av_slideshow_full size='featured' min_height='0px' stretch='' control_layout='av-control-default' src='' attachment='' attachment_size='' position='top left' repeat='no-repeat' attach='scroll' conditional_play='' animation='slide' transition_speed='' autoplay='true' interval='4' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' id='' custom_class='' av_uid='av-jub89jyb']
[av_slide_full slide_type='image' id='6180' video='http://' mobile_image='' fallback_link='http://' title='Paket aktuell wegen der Corona Beschränkungen nicht buchbar' video_format='' video_ratio='16:9' caption_pos='caption_center caption_center_framed caption_framed' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' heading_tag='' heading_class='' link_apply='' link='lightbox' link_target='' button_label='Click me' button_color='light' link1='manually,http://' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='av-2ni26v' video_autoplay='' video_controls='' video_mute='' video_loop='' overlay_enable=''][/av_slide_full]
[/av_slideshow_full]

[av_section min_height='custom' min_height_pc='25' min_height_px='700' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://www.hotelamrhein.de/wp-content/uploads/2019/06/KD-Schifffahrt-Hotel-am-Rhein-001.jpg' attachment='6180' attachment_size='full' attach='parallax' position='center center' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' custom_arrow_bg='' id='sektion-phantasialand' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-2y7dla5']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-11bslp']

[av_heading heading='KD Schiffstouren | Linienfahrt im Siebengebirge Königswinter' tag='h2' style='' subheading_active='' size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' color='' custom_font='' margin='' margin_sync='true' padding='5' link='manually,http://' link_target='' id='' custom_class='' av_uid='av-kaphuxao' admin_preview_bg=''][/av_heading]

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jub7k40s' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2s60g19' admin_preview_bg='']
Fahren Sie mit der KD direkt von Wesseling zum sagenumwobenen Drachenfels nach Königswinter.

Neben den landschaftlichen Höhepunkten erwartet Sie dort mit dem Sea Life Königswinter eine ganz besondere Freizeitattraktion. Alternativ können Sie den Drachenfels mit der Drachenfelsbahn erkunden. Die Berg- und Talfahrt ist im KD Kombiticket inkludiert.

<strong>Das KD Kombiticket beinhaltet:</strong>
<ul>
 	<li>eine Übernachtung im Doppelzimmer Superior</li>
 	<li>inklusive Frühstück</li>
 	<li>die Hin- und Rückfahrt mit dem Schiff</li>
 	<li>und wahlweise den Eintritt ins Sea Life oder die Fahrt mit der Drachenfelsbahn.</li>
</ul>
[/av_textblock]

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' id='' custom_class='' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-pw0ik7'][av_cell col_style='' av_uid='av-nl1bzb']KD Kombiticket pro Person[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-m05kuf'][av_cell col_style='' av_uid='av-l3jvrb']ab 78,00 € im DZ [/av_cell][/av_row]
[av_row row_style='' av_uid='av-jabmpz'][av_cell col_style='' av_uid='av-h7b0hz']1 Übernachtung im Doppelzimmer Superior
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-f6irsn'][av_cell col_style='' av_uid='av-dm33d3']inklusive Frühstück[/av_cell][/av_row]
[av_row row_style='' av_uid='av-buvi2f'][av_cell col_style='' av_uid='av-b1yh7r']wahlweise 1 Eintrittskarte ins Sea Life oder für eine Fahrt mit der Drachenfelsbahn[/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-8s8y5j'][av_cell col_style='' av_uid='av-7fkrg7'][av_button label='JETZT ANFRAGEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/kd-schiffstouren/#buchung' link_target='' size='large' position='center' label_display='' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-6jj7o7'][av_cell col_style='' av_uid='av-3v8zpz']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-11bslp']

[av_heading heading='KD Schiffstouren | Linienfahrt im Siebengebirge Linz' tag='h2' style='' subheading_active='' size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' color='' custom_font='' margin='' margin_sync='true' padding='5' link='manually,http://' link_target='' id='' custom_class='' av_uid='av-kaphv54g' admin_preview_bg=''][/av_heading]

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jub7k40s' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2s60g19' admin_preview_bg='']
Fahren Sie mit der KD direkt von Wesseling zum sagenumwobenen Drachenfels nach Königswinter.

Neben den landschaftlichen Höhepunkten erwartet Sie dort mit dem Sea Life Königswinter eine ganz besondere Freizeitattraktion. Alternativ können Sie den Drachenfels mit der Drachenfelsbahn erkunden. Die Berg- und Talfahrt ist im KD Kombiticket inkludiert.

<strong>Das KD Kombiticket beinhaltet:</strong>
<ul>
 	<li>eine Übernachtung im Doppelzimmer Superior</li>
 	<li>inklusive Frühstück</li>
 	<li>die Hin- und Rückfahrt mit dem Schiff</li>
 	<li>und wahlweise den Eintritt ins Sea Life oder die Fahrt mit der Drachenfelsbahn.</li>
</ul>
[/av_textblock]

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' id='' custom_class='' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-pw0ik7'][av_cell col_style='' av_uid='av-nl1bzb']KD Kombiticket pro Person[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-m05kuf'][av_cell col_style='' av_uid='av-l3jvrb']ab 78,00 € im DZ [/av_cell][/av_row]
[av_row row_style='' av_uid='av-jabmpz'][av_cell col_style='' av_uid='av-h7b0hz']1 Übernachtung im Doppelzimmer Superior
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-f6irsn'][av_cell col_style='' av_uid='av-dm33d3']inklusive Frühstück[/av_cell][/av_row]
[av_row row_style='' av_uid='av-buvi2f'][av_cell col_style='' av_uid='av-b1yh7r']wahlweise 1 Eintrittskarte ins Sea Life oder für eine Fahrt mit der Drachenfelsbahn[/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-8s8y5j'][av_cell col_style='' av_uid='av-7fkrg7'][av_button label='JETZT ANFRAGEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/kd-schiffstouren/#buchung' link_target='' size='large' position='center' label_display='' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-6jj7o7'][av_cell col_style='' av_uid='av-3v8zpz']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_one_half][/av_section][av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' id='' color='main_color' custom_bg='#ffffff' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='av-16uf6gd']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-147ybwd']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2019/06/04-06-2019-15-19-37.jpg' attachment='6192' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='av-12gnb59' admin_preview_bg=''][/av_image]

[av_gallery ids='6197,6195,6196,6198,6199' style='big_thumb' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='portfolio' columns='5' imagelink='lightbox' lazyload='avia_lazyload' av_uid='av-jwhu5gik' admin_preview_bg='']

[/av_one_third][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-11kstzx']

[av_heading heading='Erholsame Schiffstour ins Siebengebirge' tag='h3' link='manually,http://' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-gxji6f'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-ylp5zh' admin_preview_bg='']
<div class="mod_article__intro">

Als einzige Reederei befährt die KD täglich mehrfach die gesamte Strecke des UNESCO Welterbes Mittelrhein und verbindet auf optimale Weise Landschafts- und Kulturerlebnis mit Genuss und Entschleunigung.

Eines der beliebtesten Ausflugsziele ab Köln, Wesseling oder Bonn ist das Siebengebirge. Wir bringen Sie mitten hinein in dieses einzigartige Landschaftsidyll aus Burgen und Ruinen rund um die sieben Berge.

</div>
<div class="mod_article__body">
<div class="mod_text">

Gemütlich geht’s an Bord unserer Schiffe vorbei an Bonn zum sagenumwobenen Drachenfels nach Königswinter. Nutzen Sie z.B. unser preiswertes Kombiticket und entdecken Sie per Zahnradbahn das neu gestaltete Drachenfels-Plateau mit historischem Altbau und modernem Glaskubus. Wer die entspannte Zeit an Bord mit einem erlebnisreichen Landgang verbinden möchte, kann auch unser Kombiticket Sea Life lösen.

</div>
</div>
[/av_textblock]

[av_button label='JETZT ANFRAGEN' icon_select='no' icon='ue800' font='entypo-fontello' size='large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='manually,https://www.hotelamrhein.de/freizeitprogramm/kd-schiffstouren/#buchung' link_target='' id='' custom_class='' av_uid='av-jv7w2ud4' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-ylp5zh' admin_preview_bg='']
<div class="mod_article__intro"></div>
<div class="mod_article__body">
<div class="mod_text">Copyright Fotos@<a href="https://www.k-d.com/de/" target="_blank" rel="noopener">KD Deutsche Rheinschiffahrt</a></div>
</div>
[/av_textblock]

[/av_one_half]
[/av_section]

[av_slideshow_full size='featured' min_height='0px' stretch='' animation='slide' conditional_play='' autoplay='true' interval='4' control_layout='av-control-default' src='' attachment='' attachment_size='' position='top left' repeat='no-repeat' attach='scroll' av_uid='av-jub89jyb']
[av_slide_full id='6182' av_uid='av-38wt3r' slide_type='' video='http://' mobile_image='' fallback_link='http://' video_format='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' custom_title_size='' custom_content_size='' caption_pos='caption_bottom' link_apply='' link='' link_target='' button_label='Click me' button_color='light' link1='' link_target1='' button_label2='Click me' button_color2='light' link2='' link_target2='' font_color='' custom_title='' custom_content='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_slide_full]
[/av_slideshow_full]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='buchung' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-atiri5']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-9em7a5']

[av_contact title='Buchungsanfrage Kombiarrangement im Siebengebirge' button='Senden' on_send='' sent='Deine Nachricht wurde versendet!' link='manually,http://' captcha='' captcha_theme='light' captcha_size='normal' captcha_score='0.5' email='info@hotelamrhein.de' from_email='' subject='' autoresponder_email='info@hotelamrhein.de' autoresponder_reply_to='' autorespond='' form_align='' color='' heading_tag='' heading_class='' alb_description='' id='' custom_class='' aria_label='' av_uid='av-jv6noos4' admin_preview_bg='']
[av_contact_field label='Anrede' type='select' options='Frau,Herr' check='' width='element_half' av_uid='av-g2jgpj'][/av_contact_field]
[av_contact_field label='Titel' type='text' options='' check='' width='element_half' av_uid='av-eh29yv'][/av_contact_field]
[av_contact_field label='Vorname und Nachname' type='text' options='' check='is_empty' width='' av_uid='av-7kwsyl' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Telefon' type='text' options='' check='is_phone' width='element_half' av_uid='av-bryh7b'][/av_contact_field]
[av_contact_field label='E-Mail' type='text' options='' check='is_email' width='element_half' av_uid='av-bjljvb'][/av_contact_field]
[av_contact_field label='Strasse + Hausnummer' type='text' options='' check='is_empty' width='element_half' av_uid='av-8qjfnb'][/av_contact_field]
[av_contact_field label='Postleitzahl und Ort' type='text' options='' check='is_empty' width='element_half' av_uid='av-7zx56v'][/av_contact_field]
[av_contact_field label='Personenzahl' type='select' options='1,2,3,4' check='is_number' width='' av_uid='av-3jzolp' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Anreise' type='datepicker' options='' check='is_empty' width='element_half' av_uid='av-5r3rjb'][/av_contact_field]
[av_contact_field label='Abreise' type='datepicker' options='' check='is_empty' width='element_half' av_uid='av-4q2dzr'][/av_contact_field]
[av_contact_field label='Nachricht' type='textarea' check='is_empty' options='' multi_select='' av_contact_preselect='' width='' av_uid='av-1w4z5p'][/av_contact_field]
[/av_contact]

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-5acesd']

[av_heading heading='Comfort direkt am Rhein' tag='h3' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-270s5z'][/av_heading]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2l2e99' admin_preview_bg='']
Unsere 68 großen, hell und modern eingerichteten Basic Einzelzimmer, verschiedenen Doppelzimmern und Suiten in Wesseling bieten hohen Komfort und Behaglichkeit.

Neben unseren Komfort Zimmern stehen Ihnen unsere Rheinblick Zimmer, Deluxe Zimmer mit Rheinblick und Balkon, Junior Deluxe Zimmer 35m², unsere Familien Suiten 42m², sowie unsere einzigartige Rheinblick Deluxe Suite mit einer Eckbadewanne und direktem Blick auf den Rhein, zur Verfügung. Sie sind ausgestattet mit je einer Nespresso Kapselmaschine, einem Wasserkocher zur Teezubereitung und einer Falsche Selters Mineralwasser.

Unvergesslich bleibt der Blick auf den Rhein, den Sie vom größten Teil der Zimmer, der Lobby-Bar und dem Frühstücksraum aus haben.

Haustiere sind bei uns jederzeit Willkommen.

<strong>Unsere KD Kombiarrangement Siebengebirge beinhalten jeweils: </strong>
<ul>
 	<li>eine Übernachtung im Doppelzimmer Superior</li>
 	<li>inklusive Frühstück</li>
 	<li>die Hin- und Rückfahrt mit dem Schiff</li>
 	<li>und wahlweise den Eintritt ins Sea Life oder die Fahrt mit der Drachenfelsbahn</li>
</ul>
<strong>*Preise gelten pro Person | Paket aktuell wegen der Corona Beschränkungen nicht buchbar
</strong>
[/av_textblock]

[av_gallery ids='2760,2967,5228,5253,5259,5266' style='thumbnails' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='portfolio' columns='2' imagelink='lightbox' lazyload='avia_lazyload' av_uid='av-jv7vt4cl' admin_preview_bg='']

[/av_one_half]
[/av_section]";s:15:"Masonry-Galerie";s:238:"[av_masonry_gallery ids='2760,2925,2928,2966' items='4' columns='2' paginate='pagination' size='fixed masonry' gap='large' overlay_fx='' container_links='active' id='' caption_elements='none' caption_styling='' caption_display='on-hover']";s:10:"Pauschale1";s:8725:"[av_section color='main_color' custom_bg='#f8f8f8' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_one_fourth first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/hotel_1.jpg' attachment='2698' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/feier.jpg' attachment='2726' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' align='center' animation='no-animation' link='' target='']

[/av_one_fourth][av_three_fourth]

[av_textblock]
<div>
<h3>Familienfeiern - Hochzeiten - Jubiläen</h3>
</div>
<div>

Die Vorbereitung und Organisation einer Veranstaltung bringt eine Menge Arbeit mit sich.

Ob Familientreffen, Hochzeit, Taufe oder Trauerfeier - bei uns steht Ihnen ein erfahrenes Team zur Verfügung, welches Sie gerne bei der Planung, Abwicklung und Durchführung Ihrer Veranstaltung berät und unterstützt.

Legen Sie Ihre Wünsche in unsere Hände, denn die Konzeption, Organisation und Programmgestaltung sind unsere Stärke.

Bei Fragen und Wünschen steht Ihnen Frau Hauke gerne zur Seite und wird auch Ihre Veranstaltung zu einem einmaligen Erlebniss werden lassen.

Gerne vereinbaren wir einen Termin unter:
Telefon: 02236 325-0
Telafax:02236 325-199
oder E-Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

Nachfolgend finden Sie unsere Pauschalangebote, Buffetvorschläge und Getränkepauschalen. Natürlich kann auch jedes Angebot individuell erstellt werden!</div>
[/av_textblock]

[/av_three_fourth]
[/av_section]

[av_section color='main_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading heading='Unsere Pauschalangebote' tag='h3' color='' custom_font='' style='blockquote modern-quote' size='' subheading_active='' subheading_size='15' padding='15'][/av_heading]

[av_one_half first]

[av_promobox button='no' label='Click me' link='manually,http://' link_target='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' size='large' icon_select='no' icon='ue800' font='entypo-fontello']
<b>Beispiel für eine Feier mit 35 Personen:</b>

Saal Berzdorf inkl. vorhandenen Mobiliar zur Saalmiete in Höhe von € 200,00.
Veranstaltungspauschale zu € 68,50 pro Person inklusive:
<ul>
	<li>Getränkepauschale „small“</li>
	<li>Buffet I</li>
	<li>sowie Service,</li>
	<li>Tanzfläche,</li>
	<li>Tischwäsche,</li>
	<li>Technik (Nutzung der vorhandenen Beschallungsanlage),</li>
	<li>Tischdekoration (kleines Blumenarrangement & Teelichthalter aus Glas),</li>
	<li>Menükarten</li>
</ul>
zuzüglich können Stuhlhussen in weiss à € 5,95 / Stk angemietet werden.
DJ inkl. Beschallungsanlage und Lichttechnik für die Tanzfläche ab € 595,00
Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_promobox]

[/av_one_half][av_one_half]

[av_promobox button='no' label='Click me' link='manually,http://' link_target='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' size='large' icon_select='no' icon='ue800' font='entypo-fontello']
<b>Beispiel für eine Feier mit 80 Personen:</b>

Saal Berzdorf inkl. vorhandenen Mobiliar ohne Saalmiete.
Veranstaltungspauschale zu € 78,00 pro Person inklusive:
<ul>
	<li>Getränkepauschale „medium“</li>
	<li>Buffet II</li>
	<li>sowie Service,</li>
	<li>Tanzfläche,</li>
	<li>Tischwäsche,</li>
	<li>Technik (Nutzung der vorhandenen Beschallungsanlage),</li>
	<li>Tischdekoration (kleines Blumenarrangement & Teelichthalter aus Glas),</li>
	<li>Menükarten</li>
</ul>
zuzüglich können Stuhlhussen in weiss à € 5,95 / Stk angemietet werden.
DJ inkl. Beschallungsanlage und Lichttechnik für die Tanzfläche ab € 595,00
Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_promobox]

[/av_one_half]
[/av_section]

[av_section color='main_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_one_fourth first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/feier.jpg' attachment='2726' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/hotel_1.jpg' attachment='2698' align='center' animation='no-animation' link='' target='no']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' align='center' animation='no-animation' link='' target='']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/hotel_1.jpg' attachment='2698' align='center' animation='no-animation' link='' target='no']

[/av_one_fourth][av_three_fourth]

[av_heading tag='h3' padding='10' heading='Buffetideen & Getränkepauschalen' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15'][/av_heading]

[av_tab_container position='sidebar_tab sidebar_tab_left' boxed='border_tabs' initial='1']
[av_tab title='Buffet Standard' icon_select='yes' icon='ue812' font='entypo-fontello']
<b><i>Buffet</i></b>
Crêpes-Röllchen mit Lachs und Frischkäse gefüllt
Blattsalat der Saison mit zwei Dressing Paprika und Champignons gefüllt mit Frischkäse
Getrocknete Tomaten
***
Brot & Butter, Kräuterbutter
Soßen

<b><i>Warm
</i></b>Medaillon vom Schweinefilet im Speckmantel, Pfeffersauce
Rosmarinkartoffeln
Bohnen, glasierte Möhren
Hähnchenbrust auf Schmorgemüse
Weiße Nudeln

<b><i>Dessert</i></b>
Obstspieße „mediterran“
Vanillesauce
Joghurtcreme mit Himbeermark
[/av_tab]
[av_tab title='Buffet Premium' icon_select='yes' icon='ue812' font='entypo-fontello']
<b><i>Buffet</i></b>
Lachs gebeizt, Garnelensalat mit Wurzelgemüse
Puten-Tonnato mit Kapernäpfeln
Anti-Pasti:
Getrocknete Tomaten, Zucchini, marinierte Champignons
Oliven, Tomate-Mozzarella-Spieße
Raukesalat mit Pinienkernen und Parmesan
Balsamico-Dressing
Parmaschinken an mariniertem grünen Spargel
***
Brot & Butter, Soßen

<b><i>Warm
</i></b>Lammragout „Toscana“
Kartoffelgratin
Hähnchenbrust „Sizilianisch“ auf Blattspinat
Rosmarinkartoffeln
Streifen vom Salmfilet auf Wurzelgemüse, Zitronengrassauce
Weiße Nudeln

<b><i>Dessert</i></b>
Tiramisu-Schnitte
Obstsalat

Käseauswahl
Brot & Butter
[/av_tab]
[av_tab title='Getränkepauschale „small“' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Reissdorf-Kölsch</li>
	<li>Krombacher Pils</li>
	<li>1 Rotwein (Hauswein)</li>
	<li>1 Weisswein (Hauswein)</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle)</li>
	<li>Selters Mineralwasser</li>
	<li>Espresso, Café crema, Cappuccino</li>
</ul>
Ab € 29,50 pro Person *
[/av_tab]
[av_tab title='Getränkepauschale “medium”' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Sekt & O-Saft oder Sprizz/Hugo zum Empfang</li>
	<li>1 Rotwein (Auswahl aus 2 Hausweinen)</li>
	<li>1 Weisswein (Auswahl aus 2 Hausweinen)</li>
	<li>Reissdorf-Kölsch</li>
	<li>Krombacher Pils & Pils alkoholfrei</li>
	<li>Krombacher Weizen & Weizen alkoholfrei</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle)</li>
	<li>Selters Mineralwasser</li>
	<li>Kaffeespezialitäten</li>
</ul>
Ab € 36,00 pro Person *
[/av_tab]
[av_tab title='Getränkepauschale “premium”' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Champagner & Cocktail (z. B. Caipirinha, Mojito,Tequilla Sunrise, Pina Colada)</li>
	<li>2 Rotweine (Auswahl aus verschiedenen Sorten unseres Weinangebotes)</li>
	<li>2 Weissweine (Auswahl aus verschiedenen Sorten unseres Weinangebotes)</li>
	<li>1 Roséwein (Hauswein)</li>
	<li>Reissdorf-Kölsch, Reissdorf-Kölsch alkoholfrei</li>
	<li>Krombacher Pils & Pils alkoholfrei</li>
	<li>Krombacher Weizen & Weizen alkoholfrei</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle, Bitter Lemon, Ginger Ale, Tonic Water)</li>
	<li>Selters Mineralwasser</li>
	<li>Kaffeespezialitäten</li>
	<li>1 Digestif pro Person (z. B. Jubiläumsaquavit oder Linie, Williams Birne, Grappa, Korn, Ramazzotti)</li>
</ul>
Ab € 41,50 pro Person *
[/av_tab]
[/av_tab_container]

[av_textblock]
* Verlängerungsstunde: € 5,00 pro Person
Selbstverständlich können alle Getränke auch nach Verbrauch berechnet werden. Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_textblock]

[/av_three_fourth]
[/av_section]";s:16:"Phantasialand001";s:15529:"[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='sektion-phantasialand' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/03/Phantasialand-Black-Mamba_01.jpg' attachment='5489' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_three_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Auf zum Phantasialand!' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<section class="av_textblock_section ">
<div class="avia_textblock ">

Abenteuer erleben im Phantasialand und übernachten im Hotel am Rhein inklusive reichhaltigem Frühstücksbuffet.

Unsere Pakete beinhalten jeweils:
<ul>
 	<li>1 Übernachtung in der jeweiligen Zimmerkategorie</li>
 	<li>Reichhaltiges Frühstücksbuffet</li>
 	<li>1 Eintritts-/Tageskarte für das Phantasialand Brühl je Person</li>
</ul>
Paketpreis ab 134,00 €

Bitte beachten Sie, dass Kinder ab 11 Jahren im Phantasialand den vollen Eintritt zahlen.

</div>
</section>
[/av_textblock]

[av_button label='Phantasialand-Paket buchen' link='manually,#buchung' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth][av_one_third first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Einzelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']134,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']1 Erwachsener[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/freizeitpark-phantasialand/?arr=dUTLJAYR4xKgp#buchung' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Doppelzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']189,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']2 Erwachsene[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/freizeitpark-phantasialand/?arr=dUTLJAYR4xKgp#buchung' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table']
[av_row row_style='avia-heading-row'][av_cell col_style='']Familienzimmer[/av_cell][/av_row]
[av_row row_style='avia-pricing-row'][av_cell col_style='']229,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']2 Erwachsene und 2 Kinder[/av_cell][/av_row]
[av_row row_style='avia-button-row'][av_cell col_style=''][av_button label='JETZT BUCHEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/freizeitpark-phantasialand/?arr=dUTLJAYR4xKgp#buchung' link_target='' size='large' position='center' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_cell][/av_row]
[/av_table]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' id='' color='main_color' custom_bg='#ffffff' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_image src='http://har.avistado.de/wp-content/uploads/2016/02/Phantasialand_Logo_blau-300x122.jpg' attachment='4040' attachment_size='medium' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation'][/av_image]

[/av_one_third][av_two_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_heading tag='h3' padding='10' heading='Hotel am Rhein Wesseling, auf zum Phantasialand' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='']
Was 1967 als stiller Märchenpark begann, ist heute einer der besucherstärksten Freizeitparks Deutschlands.
Erleben Sie wieder Spaß , Action, Abenteuer und Nervenkitzel auf den verschiedenen Attraktionen und Shows im Phantasialand in Brühl.

Neben den bekannten Fahr-Abenteuern wie der Black Mamba, der Colorado Advendture und Talocan, können Sie mit Chiapas, die steilste und modernste Wildwasserbahn weltweit erleben.

Lassen Sie sich mitnehmen auf die aufregende Reise der Entstehung der neuen faszinierenden Themenwelt Klugheim mit der spektakulären Attraktion TARON, Europas schnellstem Multi-Launch-Coaster!

Diese und viele weitere Attraktionen, Shows und Überraschungen warten auf Sie und Ihre ganze Familie.
[/av_textblock]

[/av_two_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='buchung' color='main_color' custom_bg='#ffffff' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_hr class='default' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='']

[av_heading tag='h2' padding='10' heading='Jetzt das Phantasialand Paket im Hotel am Rhein buchen! ' color='' style='blockquote modern-quote modern-centered' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<!-- Viato CBE bookingFrame -->
<div id="viatoCbe"><!-- Loading Viato CBE bookingFrame -->
<script src="https://booking.viatocrs.de/cbe/viato-cbe.js?pr=W0edyg5Br0l4"></script></div>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' id='' color='main_color' custom_bg='#ffffff' src='http://har.avistado.de/wp-content/uploads/2016/02/Phantasialand-CHIAPAS_DIE_Wasserbahn_01.jpg' attachment='4054' attachment_size='full' attach='parallax' position='top center' repeat='no-repeat' video='' video_ratio='16:9' overlay_enable='aviaTBoverlay_enable' overlay_opacity='0.8' overlay_color='#ffffff' overlay_pattern='' overlay_custom_pattern='']
[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_heading tag='h3' padding='10' heading='Attraktionen, Shows und Achterbahnen!' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
Entdecken Sie Action der Extraklasse. Folgende Höhepunkte warten u.a. auf Sie:
[/av_textblock]

[av_slideshow size='entry_without_sidebar' animation='slide' autoplay='true' interval='5' control_layout='']
[av_slide slide_type='image' id='4064' video='' mobile_image='' video_ratio='' title='Chipas Wildwasserbahn' link_apply='' link='lightbox' link_target='' video_controls='' video_mute='' video_loop='' video_autoplay='']
Die größte Wildwasserbahn wo gibt. Es geht steil bergab und wird spritzig
[/av_slide]
[av_slide slide_type='image' id='4068' video='' mobile_image='' video_ratio='' title='Mystery Castle' link_apply='' link='lightbox' link_target='']
Free Fall der Extraklasse. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam.
[/av_slide]
[av_slide slide_type='image' id='4067' video='' mobile_image='' video_ratio='' title='Fantissima' link_apply='' link='lightbox' link_target='' video_controls='' video_mute='' video_loop='' video_autoplay='']
Hier wird's romantisch. Packen Sie Ihren Liebsten oder oder Liebste und lassen Sie sich verzaubern
[/av_slide]
[/av_slideshow]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' scroll_down='' id='' color='main_color' custom_bg='' src='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' video_mobile_disabled='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_masonry_gallery ids='2760,2925,2928,2966' items='5' columns='2' paginate='pagination' size='fixed masonry' gap='no' overlay_fx='' caption_elements='none' caption_display='on-hover' container_links='active' id='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_heading tag='h3' padding='10' heading='Comfort direkt am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
Unsere 68 großen, hell und modern eingerichteten Einzelzimmer, Doppelzimmer und Suiten in Wesseling bieten hohen Komfort und Behaglichkeit. Neben unseren Komfort-Zimmern stehen Ihnen Superior-Zimmer mit Rheinblick und Wasserkocher zur Kaffee- und Teezubereitung sowie 2 Juniorsuiten, 3 Familiensuiten und eine Rheinblicksuite je nach Verfügbarkeit zur Verfügung.

Unvergesslich bleibt der Blick auf den Rhein, den Sie vom größten Teil der Zimmer, der Lobby-Bar und dem Frühstücksraum aus haben.

Haustiere sind bei uns jederzeit Willkommen.

<strong>Unsere Pakete beinhalten jeweils: </strong>
<ul>
 	<li>1 Übernachtung in der jeweiligen Zimmerkategorie</li>
 	<li>Reichhaltiges Frühstücksbuffet</li>
 	<li>1 Eintritts-/Tageskarte für das Phantasialand Brühl je Person</li>
</ul>
Bitte beachten Sie, dass Kinder ab 11 Jahren im Phantasialand den vollen Eintritt zahlen.
[/av_textblock]

[/av_one_half]
[/av_section]";s:9:"Radfahren";s:13246:"[av_section min_height='custom' min_height_pc='25' min_height_px='850px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/fahrradtour_rhein.jpg' attachment='5741' attachment_size='full' attach='parallax' position='top center' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-2y7dla5']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-2wq883x']

[/av_one_third][av_two_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-11bslp']

[av_heading heading='Das Rheinland mit dem Rad erkunden' tag='h2' link='manually,http://' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-181qwbv'][/av_heading]

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jub7k40s' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2s60g19' admin_preview_bg='']
<section class="av_textblock_section ">In Kooperation mit der <a href="https://www.radstationkoeln.de/" target="_blank" rel="noopener">Radstation Köln</a> bieten wir Ihnen qualitativ hochwertige City-Bikes zu fairen Preisen.

Die Radstation Köln (zentral gelegen am Kölner Hauptbahnhof) bietet Ihnen Mountainbikes, Trekkingräder, Tandems, Kinderräder, E-Bikes und Fahrzeuge zur Behindertenmobilität.

Fragen Sie an unserer Rezeption nach dem Fahrradverleih.

</section>
[/av_textblock]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Radstation-Köln-ohne-Hbf-1030x294.jpg' attachment='3856' attachment_size='large' copyright='' caption='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='' target='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kafrigfj' admin_preview_bg=''][/av_image]

[/av_two_third][av_one_third first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-2ojqdfx']

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-26953hp']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' id='' custom_class='' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-15vptsb'][av_cell col_style='' av_uid='av-152lavf']1 Übernachtung[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-12sfhe3'][av_cell col_style='' av_uid='av-10v64l7']ab 69,50 € im DZ[/av_cell][/av_row]
[av_row row_style='' av_uid='av-10as14b'][av_cell col_style='' av_uid='av-ydj3qz']1 Übernachtung in der jeweiligen Zimmerkategorie
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-w7h6cb'][av_cell col_style='' av_uid='av-uxhnkr']inklusive Frühstück [/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-su7luj'][av_cell col_style='' av_uid='av-re9r17'][av_button label='JETZT ANFRAGEN' icon_select='no' icon='ue87d' font='entypo-fontello' size='large' position='center' label_display='' title_attr='' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' link='manually,#buchung-radstation' link_target='' id='' custom_class='' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-p5hfyj'][av_cell col_style='' av_uid='av-op78kb']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-26953hp']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' id='' custom_class='' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-luwbor'][av_cell col_style='' av_uid='av-kkofzv']2 Übernachtungen[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-j0d1vv'][av_cell col_style='' av_uid='av-hrwm57']ab 109,25 € im DZ[/av_cell][/av_row]
[av_row row_style='' av_uid='av-1mq49n'][av_cell col_style='' av_uid='av-edv6kb']2 Übernachtungen in der jeweiligen Zimmerkategorie
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-cpdbsb'][av_cell col_style='' av_uid='av-bgptez']inklusive Frühstück [/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-9rtdy3'][av_cell col_style='' av_uid='av-81s0pn'][av_button label='JETZT ANFRAGEN' icon_select='no' icon='ue87d' font='entypo-fontello' size='large' position='center' label_display='' title_attr='' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' link='manually,#buchung-radstation' link_target='' id='' custom_class='' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-64a39n'][av_cell col_style='' av_uid='av-gwugb']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='buchung-radstation' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-atiri5']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-9em7a5']

[av_contact title='Buchungsanfrage Radstation Köln' button='Senden' on_send='' sent='Deine Nachricht wurde versendet!' link='manually,http://' captcha='' captcha_theme='light' captcha_size='normal' captcha_score='0.5' email='info@hotelamrhein.de' from_email='' subject='' autoresponder_email='info@hotelamrhein.de' autoresponder_reply_to='' autorespond='' form_align='' color='' heading_tag='' heading_class='' alb_description='' id='' custom_class='' aria_label='' av_uid='av-jv6noos4' admin_preview_bg='']
[av_contact_field label='Anrede' type='select' options='Frau,Herr' check='' width='element_half' av_uid='av-f2xydp' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Titel' type='text' options='' check='' width='element_half' av_uid='av-evqe8t' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Vorname und Nachname' type='text' options='' check='is_empty' width='' av_uid='av-7kwsyl' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Telefon' type='text' options='' check='is_phone' width='element_half' av_uid='av-d7qz1p' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='E-Mail' type='text' options='' check='is_email' width='element_half' av_uid='av-bead31' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Strasse + Hausnummer' type='text' options='' check='is_empty' width='element_half' av_uid='av-9h3d5p' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Postleitzahl und Ort' type='text' options='' check='is_empty' width='element_half' av_uid='av-otowd' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Personenzahl' type='select' options='1,2,3,4' check='is_number' width='' av_uid='av-3jzolp' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Anreise' type='datepicker' options='' check='is_empty' width='element_half' av_uid='av-5o6ivx' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Abreise' type='datepicker' options='' check='is_empty' width='element_half' av_uid='av-3xjq1p' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Nachricht' type='textarea' check='is_empty' options='' multi_select='' av_contact_preselect='' width='' av_uid='av-1w4z5p'][/av_contact_field]
[/av_contact]

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-5acesd']

[av_heading heading='Comfort direkt am Rhein' tag='h3' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-26bpi3'][/av_heading]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2l2e99' admin_preview_bg='']
Unsere 68 großen, hell und modern eingerichteten Basic Einzelzimmer, verschiedenen Doppelzimmern und Suiten in Wesseling bieten hohen Komfort und Behaglichkeit.

Neben unseren Komfort Zimmern stehen Ihnen unsere Rheinblick Zimmer, Deluxe Zimmer mit Rheinblick und Balkon, Junior Deluxe Zimmer 35m², unsere Familien Suiten 42m², sowie unsere einzigartige Rheinblick Deluxe Suite mit einer Eckbadewanne und direktem Blick auf den Rhein, zur Verfügung. Sie sind ausgestattet mit je einer Nespresso Kapselmaschine, einem Wasserkocher zur Teezubereitung und einer Falsche Selters Mineralwasser.

Unvergesslich bleibt der Blick auf den Rhein, den Sie vom größten Teil der Zimmer, der Lobby-Bar und dem Frühstücksraum aus haben.

Haustiere sind bei uns jederzeit Willkommen.

<strong>Unsere Pakete beinhalten jeweils: </strong>
<ul>
 	<li>1 Übernachtung in der jeweiligen Zimmerkategorie</li>
 	<li>inklusive Frühstück</li>
</ul>
*Preise gelten pro Person
[/av_textblock]

[av_gallery ids='2760,2967,5228,5253,5259,5266' style='thumbnails' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='portfolio' columns='2' imagelink='lightbox' lazyload='avia_lazyload' av_uid='av-jv7vt4cl' admin_preview_bg='']

[/av_one_half]
[/av_section]";s:14:"Start 20200427";s:18695:"[av_fullscreen size='no scaling' image_attachment='' animation='slide' conditional_play='' autoplay='false' interval='5' control_layout='av-control-default' av_uid='av-jxkd6x6g']
[av_fullscreen_slide slide_type='image' id='6050' position='center center' video='http://' mobile_image='' fallback_link='http://' video_cover='' title='AUF ZUM PHANTASIALAND!' custom_title_size='' custom_content_size='' caption_pos='caption_left caption_left_framed caption_framed' link_apply='button' link='lightbox' link_target='' button_label='Phantasialand-Paket buchen' button_color='light' link1='manually,https://www.hotelamrhein.de/freizeitprogramm/freizeitpark-phantasialand/?arr=dUTLJAYR4xKgp#buchung' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-36hw78' video_controls='' video_mute='' video_loop='' video_autoplay='' overlay_enable='']
Übernachtung im Einzelzimmer mit Park-Ticket ab 134,00 €
[/av_fullscreen_slide]
[av_fullscreen_slide slide_type='image' id='6199' position='center center' video='http://' mobile_image='' fallback_link='http://' video_cover='' title='KD SCHIFFSTOUREN | KOMBIARRANGEMENT IM SIEBENGEBIRGE' custom_title_size='' custom_content_size='' caption_pos='caption_left caption_left_framed caption_framed' link_apply='button' link='lightbox' link_target='' button_label='Jetzt KD-Kombiticket anfragen!' button_color='light' link1='manually,https://www.hotelamrhein.de/freizeitprogramm/kd-schiffstouren/#buchung' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-4eayw4']
Fahren Sie mit der KD direkt von Wesseling zum sagenumwobenen Drachenfels nach Königswinter ab 78,00 € p.P.
[/av_fullscreen_slide]
[av_fullscreen_slide slide_type='image' id='6129' position='center center' video='http://' mobile_image='' fallback_link='http://' video_cover='' title='URLAUB IM PARADIES – DIE THERME EUSKIRCHEN' custom_title_size='' custom_content_size='' caption_pos='caption_left caption_left_framed caption_framed' link_apply='button' link='lightbox' link_target='' button_label='Jetzt Auszeit anfragen!' button_color='light' link1='manually,https://www.hotelamrhein.de/freizeitprogramm/therme-euskirchen/#buchung' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-328fic']
Genießen Sie eine Auszeit in der Therme Euskirchen in Kombination mit einer Übernachtung im Hotel am Rhein ab 83,50 € p.P.
[/av_fullscreen_slide]
[/av_fullscreen]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-1ud9ec4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' av_uid='av-1sphh78']
<div class="viato-price-widget">
<iframe scrolling='no' id='pw-price-widget' src='https://price-widget.viato.travel/?k_id=W0edyg5Br0l4'></iframe>
</div>
[/av_codeblock]

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/2FP0369.jpg' attachment='2925' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-1rymttg']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-1qr9eec']

[av_heading tag='h2' padding='5' heading='Unsere Zimmer' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-1p55ph0'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-1me5r04']
<div>
<ul>
 	<li>Wählen Sie aus 68 Zimmern, davon viele mit Rheinblick</li>
 	<li>Wir bieten ebenfalls Junior- und Familiensuiten</li>
 	<li>Ihr Haustier ist bei uns willkommen</li>
 	<li>WLAN mit Highspeed-Internet</li>
</ul>
</div>
[/av_textblock]

[av_button label='Unsere Zimmer' link='page,4933' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='' av_uid='av-1kqw1qc']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-1jaxc1w']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/hochzeiten_und_events.jpg' attachment='5743' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-1i6kko4']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-1gkf60k']

[av_heading tag='h2' padding='5' heading='Tagungen & Events' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-1ekekok'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-1cwa0as']
<div>

Ob Firmenveranstaltung, Hochzeit, Taufe oder zu einem anderen Anlass – wir machen Ihr Event zu einem ganz besonderen Erlebnis.

</div>
[/av_textblock]

[av_button label='Tagungen & Events' link='page,4938' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='' av_uid='av-1ayc7v8']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-19npc1w']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/08/HAR_web-305.jpg' attachment='5883' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-17eklg4']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-16x1lec']

[av_heading tag='h2' padding='5' heading='Unsere Rheinbar' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-14f67ms'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-13or7is']
Genießen Sie warme Speisen, alkoholfreie oder alkoholische Getränke an unserer Rheinbar.
[/av_textblock]

[av_button label='Speisen & Getränke' link='manually,https://www.hotelamrhein.de/wp-content/uploads/2018/08/Rheinbar.pdf' link_target='_blank' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='' av_uid='av-11cc5no']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-z8pw44']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/freizeitprogramm.jpg' attachment='5742' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-yo0v4k']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-wl4j84']

[av_heading heading='Freizeitprogramm' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='5' color='' custom_font='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-u4d8d0'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-se9pys']
<div>

Die Umgebung unseres Hotels bietet ein umfangreiches Freizeitprogramm für die ganze Familie. Neben dem bekannten Phantasialand in Brühl erwarten Sie wunderschöne Radwege, Schiffstouren auf dem Rhein und vieles mehr...

</div>
[/av_textblock]

[av_button label='Freizeitprogramm' link='page,4742' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='' av_uid='av-r90610']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-p19kz8']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/service_und_kontakt.jpg' attachment='5747' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-2dnfxw']
[av_two_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-midc1w']

[av_heading heading='Service & Kontakt' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='5' color='' custom_font='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-k57hok'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-jjh63o']
<div>

Unser kompetentes Team steht Ihnen gerne mit Rat und Tat zur Seite. Rufen Sie uns an oder schreiben Sie uns eine Email...

</div>
[/av_textblock]

[av_button label='Service & Kontakt' link='page,2334' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='' av_uid='av-i1rnmc']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-gdeilg']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/07/youtube-tn-001.jpg' attachment='5832' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-e7ky44']
[av_one_third first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-d3vz7o']

[av_heading tag='h2' padding='5' heading='Unser Imagefilm' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-14wi44'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-9e3vl0']
Erfahren Sie mehr über das Hotel am Rhein und seine Leistungen.
[/av_textblock]

[av_button label='Imagefilm' link='manually,https://www.youtube.com/watch?v=vrKbexTqcUQ' link_target='_blank' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='' av_uid='av-70fdx0']

[/av_one_third][av_two_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-5gk2ic']

[av_video src='https://www.youtube.com/watch?v=vrKbexTqcUQ' format='16-9' width='16' height='9' av_uid='av-45b3xw']

[/av_two_third]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-2hujr8']";s:15:"Start Ende 2018";s:16323:"[av_fullscreen size='no scaling' image_attachment='' animation='slide' autoplay='true' interval='5' control_layout='av-control-hidden' scroll_down='aviaTBscroll_down']
[av_fullscreen_slide slide_type='image' id='5841' position='bottom left' video='http://' mobile_image='' video_cover='' title='Herzlich willkommen im Hotel am Rhein' custom_title_size='' custom_content_size='' caption_pos='caption_bottom caption_bottom_framed caption_framed' link_apply='' link='lightbox' link_target='' button_label='Click me' button_color='light' link1='manually,http://' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' video_controls='' video_mute='' video_loop='' video_autoplay='' overlay_enable=''][/av_fullscreen_slide]
[av_fullscreen_slide slide_type='image' id='5942' position='center center' video='' mobile_image='' video_cover='' title='' custom_title_size='' custom_content_size='' caption_pos='caption_right caption_right_framed caption_framed' link_apply='' link='lightbox' link_target='' button_label='' button_color='light' link1='manually,http://' link_target1='' button_label2='' button_color2='light' link2='manually,http://' link_target2='' font_color='' custom_title='' custom_content='' overlay_opacity='0.1' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_fullscreen_slide]
[/av_fullscreen]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_codeblock wrapper_element='' wrapper_element_attributes='']
<div class="viato-price-widget">
<iframe scrolling='no' id='pw-price-widget' src='https://price-widget.viato.travel/?k_id=W0edyg5Br0l4'></iframe>
</div>
[/av_codeblock]

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/2FP0369.jpg' attachment='2925' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Unsere Zimmer' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>
<ul>
 	<li>Wählen Sie aus 68 Zimmern, davon viele mit Rheinblick</li>
 	<li>Wir bieten ebenfalls Junior- und Familiensuiten</li>
 	<li>Ihr Haustier ist bei uns willkommen</li>
 	<li>WLAN mit Highspeed-Internet</li>
</ul>
</div>
[/av_textblock]

[av_button label='Unsere Zimmer' link='page,4933' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/hochzeiten_und_events.jpg' attachment='5743' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Tagungen & Events' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>

Ob Firmenveranstaltung, Hochzeit, Taufe oder zu einem anderen Anlass – wir machen Ihr Event zu einem ganz besonderen Erlebnis.

</div>
[/av_textblock]

[av_button label='Tagungen & Events' link='page,4938' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/08/HAR_web-305.jpg' attachment='5883' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Unsere Rheinbar' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
Genießen Sie warme Speisen, alkoholfreie oder alkoholische Getränke an unserer Rheinbar.
[/av_textblock]

[av_button label='Speisen & Getränke' link='manually,https://www.hotelamrhein.de/wp-content/uploads/2018/08/Rheinbar.pdf' link_target='_blank' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/freizeitprogramm.jpg' attachment='5742' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading heading='Freizeitprogramm' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='5' color='' custom_font='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>

Die Umgebung unseres Hotels bietet ein umfangreiches Freizeitprogramm für die ganze Familie. Neben dem bekannten Phantasialand in Brühl erwarten Sie wunderschöne Radwege, Schiffstouren auf dem Rhein und vieles mehr...

</div>
[/av_textblock]

[av_button label='Freizeitprogramm' link='page,4742' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/service_und_kontakt.jpg' attachment='5747' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_two_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading heading='Service & Kontakt' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='5' color='' custom_font='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
<div>

Unser kompetentes Team steht Ihnen gerne mit Rat und Tat zur Seite. Rufen Sie uns an oder schreiben Sie uns eine Email...

</div>
[/av_textblock]

[av_button label='Service & Kontakt' link='page,2334' link_target='' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/07/youtube-tn-001.jpg' attachment='5832' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0']
[av_one_third first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_heading tag='h2' padding='5' heading='Unser Imagefilm' color='' style='' custom_font='' size='' subheading_active='' subheading_size='15' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='']
Erfahren Sie mehr über das Hotel am Rhein und seine Leistungen.
[/av_textblock]

[av_button label='Imagefilm' link='manually,https://www.youtube.com/watch?v=vrKbexTqcUQ' link_target='_blank' size='x-large' position='left' icon_select='no' icon='ue800' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' admin_preview_bg='']

[/av_one_third][av_two_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='']

[av_video src='https://www.youtube.com/watch?v=vrKbexTqcUQ' format='16-9' width='16' height='9']

[/av_two_third]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='']";s:10:"Startseite";s:12936:"[av_layerslider id='3']

[av_section color='alternate_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Unser Service für Sie' color='' style='' custom_font='' size='' subheading_active='' subheading_size='' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box icon='ue8ab' font='entypo-fontello' position='left' title='Online-Buchung' link='page,2613' linktarget='' linkelement='']
Hier können Sie Ihr Einzelzimmer, Doppelzimmer oder Ihre Suite in unserem Hotel am Rhein direkt online buchen!

Klicken Sie einfach hier und reservieren Sie noch heute garantiert zum besten Preis.
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Zur-Buchung-001.png' attachment='3150' align='left' animation='no-animation' link='page,2613' target=''][/av_image]

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='1' font='entypo-fontello' position='left' title='Ihr Kontakt zu uns' link='' linktarget='' linkelement='']
<strong>Hotel am Rhein – Wesseling</strong>
Auf dem Rheinberg 2
50389 Wesseling

Telefon: +49(0)2236/325-0
Telefax: +49(0)2236/325-199
E-Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

Amadeus Code: HNZCK3G6
[/av_icon_box]

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue81f' font='entypo-fontello' position='left' title='Anfahrt' link='' linktarget='' linkelement='']
Sie können uns ideal mit dem Auto oder auch mit der Bahn erreichen. Vor dem Hotel finden Sie einen großen Parkplatz und die Haltestelle der Straßenbahnlinie 16 ist nur wenige Minuten von uns entfernt. <a title="Anfahrt" href="https://www.hotelamrhein.de//?page_id=2344">Details zur Anfahrt finden Sie hier! </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue812' font='entypo-fontello' position='left' title='Qualität &amp; Service' link='' linktarget='' linkelement='']
"ankommen und wohfühlen", das ist unser Anspruch im Hotel am Rhein in Wesseling.

Was vor 12 Jahren begann, ist heute gelebte Qualität, die wir lieben. <a title="Qualtität &amp; Service" href="https://www.hotelamrhein.de/?page_id=3372">Erfahren Sie mehr...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2014/05/11-Jahre-Quali-001.jpg' attachment='3587' align='center' animation='no-animation' link='page,3372' target=''][/av_image]

[/av_one_fourth]
[/av_section]

[av_section color='main_color' custom_bg='#f8f8f8' src='' attachment='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Hotel am Rhein wird Nichtraucherhotel' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_one_third first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2014/03/HAR_web-201.jpg' attachment='3575' align='left' animation='no-animation' link='' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_third][av_two_third]

[av_textblock ]
<strong>Zum 01. Dezember werden wir unser Haus zum Nichtraucher Hotel umstellen.</strong>

Die große Mehrheit unserer Gäste wünscht sich rauchfreie Zimmer, daher wird es in Zukunft keine Raucherzimmer mehr geben. Wir sind uns sicher, dass dies die Qualität unserer Hotels und Ihres Aufenthaltes bei uns weiter positiv beeinflussen wird.

Wir hoffen Sie unterstützen uns in dieser Entscheidung und freuen uns auf Ihren nächsten Besuch bei uns.

Sollten Sie Fragen haben, stehen wir Ihnen gerne unter

Telefon: 02236 325-0
Telefax: 02236 325-199
oder E-Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

zur Verfügung!
[/av_textblock]

[/av_two_third]
[/av_section]

[av_section color='alternate_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Ausflüge mit dem Hotel am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10'][/av_heading]

[av_one_fourth first]

[av_icon_box icon='ue809' font='entypo-fontello' position='left' title='Auf zum Phantasialand' link='' linktarget='' linkelement='']
Bei uns können Sie das Phantasialand-Special buchen. <strong>Unser Angebot für Sie: </strong>1 Übernachtung im Doppelzimmer inklusive reichhaltigem Frühstücksbuffet und eine Tageskarte für das Phantasialand in Brühl.

Und natürlich gibt es bei uns auch noch mehr Ausflugsangebote. Sprechen Sie uns einfach an. <a title="Freizeitpark Phantasialand" href="https://www.hotelamrhein.de/?page_id=2556">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Afriika_Winter.jpg' attachment='3242' align='center' animation='no-animation' link='' target='']

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='86' font='entypo-fontello' position='left' title='Für Fahrradfahrer' link='' linktarget='' linkelement='']Bei uns sind Radfahrer jederzeit herzlich Willkommen. Unser Hotel liegt an den schönsten Fahrradstrecken in der Kölner Rheinregion.

Sie können Ihre Fahrräder bei uns sicher und kostenfrei unterstellen und für kleine Reperaturen steht Ihnen auch ein Werkzeug Set zur Verfügung. <a title="Radfahr Special" href="https://www.hotelamrhein.de/?page_id=2560">Erfahren Sie mehr...</a>

[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Bett_Bike-Logo2011_farbig_kleine_Darstellung_jpg.jpg' attachment='3175' align='center' animation='no-animation' link='' target='']

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue83f' font='entypo-fontello' position='left' title='Kletterspaß und Abenteuer' link='' linktarget='' linkelement='']
Einmal gemeinsam mit Ihrem Partner oder Gleichgesinnten die Wand hoch gehen.

Mit über 2600 Quadratmeter Kletterwand – indoor und outdoor – ist die BRONX Rock Kletterhalle die größte Indoor-Kletterhalle Deutschlands. <a title="BronxRock – Kletterspaß" href="https://www.hotelamrhein.de/?page_id=2552">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/35691e81a4.jpg' attachment='3173' align='center' animation='no-animation' link='' target='']

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue8ce' font='entypo-fontello' position='left' title='Kurzurlaub am Rhein' link='' linktarget='' linkelement='']
Könnte es etwas schöneres geben als direkt am Rhein zu entspannen?

Genießen Sie das herrliche Panorama mit den vorbeiziehenden Schiffen und lassen Sie sich von der Gastfreundschaft am Rhein verwöhnen. <a title="Kurzurlaub am Rhein" href="https://www.hotelamrhein.de/?page_id=2554">Mehr erfahren...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' align='center' animation='no-animation' link='' target='']

[/av_one_fourth]
[/av_section]

[av_section color='alternate_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Tagungen, Konferenzen &amp; Events' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10'][/av_heading]

[av_one_fourth first]

[av_icon_box icon='ue8bb' font='entypo-fontello' position='left' title='Tagungen' link='page' linktarget='' linkelement='']In unserem Haus können Sie drei verschiedene, zeitgemäß ausgestattete und ebenerdig gelegene Tagungsräume mit 24 m², 45 m² und 123 m² nutzen.

Sie werden genügend Platz für die gewünschte Bestuhlung und die angefragte Tagungstechnik haben. <a title="Business" href="https://www.hotelamrhein.de/?page_id=2522">Mehr Informationen... </a>

[/av_icon_box]

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue80b' font='entypo-fontello' position='left' title='Familienfeiern' link='' linktarget='' linkelement='']Ob Familientreffen, Taufe oder Trauerfeier – bei uns steht Ihnen ein erfahrenes Team zur Verfügung.

Wir unterstützten Sie gerne bei der Planung, Abwicklung und Durchführung Ihrer Veranstaltung. <a title="Familienfeiern" href="https://www.hotelamrhein.de/?page_id=2516">Mehr Informationen... </a>

[/av_icon_box]

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue8f1' font='entypo-fontello' position='left' title='Hochzeiten' link='' linktarget='' linkelement='']Sie können bei uns auch den schönsten Tag Ihres Lebens feiern. Wir bieten Ihnen alle Möglichkeiten Ihre Traumhochzeit mit Rheinblick zu erleben.

Egal ob Sie dabei in einem kleinen intimen Kreis feiern wollen oder eine große Party ausrichten. <a title="Familienfeiern" href="https://www.hotelamrhein.de/?page_id=2516">Mehr Informationen... </a>

[/av_icon_box]

[/av_one_fourth][av_one_fourth]

[av_icon_box icon='ue801' font='entypo-fontello' position='left' title='Events' link='' linktarget='' linkelement='']Mit dem benachbarten “Rheinforum” bieten wir Ihnen eine Eventhalle der besonderen Art mit Platz für bis zu 800 Personen.

Unser Team stellt eine professionelle Organisation und Planung Ihrer Veranstaltung sicher. <a title="Business" href="https://www.hotelamrhein.de/?page_id=2522">Mehr Informationen… </a>

[/av_icon_box]

[/av_one_fourth]
[/av_section]

[av_section color='alternate_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Weihnachtsfeiern im Hotel am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_three_fifth first]

[av_textblock]
Die Weihnachtsfeier ist eine schöne Gelegenheit, den Mitarbeitern, Kunden oder Partnern DANKE zu sagen.

Vorbereitung und Organisation einer Veranstaltung bringt eine Menge Arbeit mit sich.  Bei uns steht Ihnen ein erfahrenes Team zur Verfügung, welches Sie gerne bei der Planung, Abwicklung und Durchführung Ihrer Weihnachtsfeier berät und unterstützt.

Lassen Sie sich von unseren unseren Arrangements inspirieren. Natürlich kann auch jedes Angebot individuell gestaltet werden!

<strong>“Ankommen &amp; Wohlfühlen” – Wir freuen uns darauf, Ihr Event gestalten zu dürfen.</strong>
[/av_textblock]

[av_hr class='invisible' height='50' shadow='no-shadow' position='center']

[av_button label='Weitere Infos zu unseren Weihnachts-Angeboten' link='page,3650' link_target='' color='custom' custom_bg='#faba00' custom_font='#1e1e1e' size='medium' position='left' icon_select='yes' icon='ue809' font='entypo-fontello']

[/av_three_fifth][av_two_fifth]

[av_slideshow size='gallery' animation='slide' autoplay='true' interval='5']
[av_slide id='3661' slide_type='' video='http://' mobile_image='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' link_apply='' link='' link_target=''][/av_slide]
[av_slide id='3660' slide_type='' video='http://' mobile_image='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' link_apply='' link='' link_target=''][/av_slide]
[av_slide id='3681' slide_type='' video='http://' mobile_image='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' link_apply='' link='' link_target=''][/av_slide]
[/av_slideshow]

[/av_two_fifth]
[/av_section]

[av_one_half first]
[av_heading heading='Ihr Weg direkt zu uns' tag='h4' color='meta-heading' style='' padding='20']

[av_textblock]
<iframe src="https://maps.google.de/maps?ie=UTF8&amp;q=Hotel+am+Rhein&amp;fb=1&amp;gl=de&amp;hq=hotel+am+Rhein&amp;hnear=0x47bf1b71c2d9a62f:0xc908abc06de74b1a,Swisttal&amp;cid=0,0,17093027715360625573&amp;t=m&amp;ll=50.871195,6.984558&amp;spn=0.111579,0.166168&amp;z=12&amp;iwloc=A&amp;output=embed" width="484" height="515" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
[/av_textblock]
[/av_one_half]

[av_one_half]
[av_heading tag='h4' padding='20' heading='Kontaktieren Sie uns' color='meta-heading' style='' custom_font='' size='' subheading_active='' subheading_size=''][/av_heading]

[av_contact email='info@hotelamrhein.de' button='Senden' title='' sent='Ihre Nachricht wurde versendet!' subject='' autorespond='' captcha='active']
[av_contact_field label='Name' type='text' options='' check='is_empty' width='']
[av_contact_field label='Email' type='text' options='' check='is_email' width='']
[av_contact_field label='Betreff' type='text' options='' check='is_empty' width='']
[av_contact_field label='Nachricht' type='textarea' options='' check='is_empty' width='']
[/av_contact]
[/av_one_half]";s:19:"Startseite-20170523";s:16941:"[av_layerslider id='9']

[av_section color='alternate_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Unser Service für Sie' color='' style='' custom_font='' size='' subheading_active='' subheading_size='' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue8ab' font='entypo-fontello' title='Online-Buchung' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' linktarget='_blank' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Hier können Sie Ihr Einzelzimmer, Doppelzimmer oder Ihre Suite in unserem Hotel am Rhein direkt online buchen!

Klicken Sie einfach hier und reservieren Sie noch heute garantiert zum besten Preis.
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Zur-Buchung-001.png' attachment='3150' attachment_size='' align='left' styling='' hover='' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' target='_blank' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation'][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='1' font='entypo-fontello' title='Kontakt' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
<strong>Hotel am Rhein – Wesseling</strong>
Auf dem Rheinberg 2
50389 Wesseling

Tel: +49 (0) 2236 / 325 0
Fax: +49 (0) 2236 / 325 199
Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

Amadeus Code: HNZCK3G6
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue812' font='entypo-fontello' title='Qualität & Service' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
"ankommen und wohfühlen", das ist unser Anspruch im Hotel am Rhein in Wesseling.

Was vor 14 Jahren begann, ist heute gelebte Qualität, die wir lieben. <a title="Qualtität & Service" href="https://www.hotelamrhein.de/?page_id=3372">Erfahren Sie mehr...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/14-Jahre-Quali-001.png' attachment='4522' attachment_size='full' align='center' styling='' hover='' link='page,3372' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation'][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue82b' font='entypo-fontello' title='Bewertung' link='page,4496' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Wir vertrauen TrustYou damit Sie uns vertrauen können.

Lassen Sie sich doch einfach von dem Feedback der Gäste vor Ihnen überzeugen.
[/av_icon_box]

[av_codeblock wrapper_element='' wrapper_element_attributes='']
<iframe src="http://api.trustyou.com/hotels/e458494e-b7cb-4b56-a431-bd1f7762f965/seal.html?size=big" allowtransparency="true" frameborder="0" width="170" height="144" scrolling="no"></iframe>
[/av_codeblock]

[av_textblock size='' font_color='' color='']
<a href="https://www.hotelamrhein.de/unsere-bewertungen/">Zu den Bewertungen</a>
[/av_textblock]

[/av_one_fourth]
[/av_section]

[av_section color='main_color' custom_bg='#f8f8f8' src='' attachment='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' min_height='' padding='small' shadow='shadow' id='']
[av_one_half first]

[av_heading tag='h3' padding='20' heading='Hotel am Rhein ist ein Nichtraucherhotel' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
<strong><img class="alignleft size-medium wp-image-3911" src="https://www.hotelamrhein.de/wp-content/uploads/2013/04/herz-300x282.png" alt="herz" width="300" height="282" />Die große Mehrheit unserer Gäste wünscht sich rauchfreie Zimmer, daher gibt es keine Raucherzimmer mehr!</strong>

Wir sind uns sicher, dass dies die Qualität unserer Hotels und Ihres Aufenthaltes bei uns weiter positiv beeinflussen wird.

Wir hoffen Sie unterstützen uns in dieser Entscheidung und freuen uns auf Ihren nächsten Besuch bei uns.
[/av_textblock]

[/av_one_half][av_one_half]

[av_heading tag='h3' padding='20' heading='Erkunden Sie das schöne Rheinland mit dem Fahrrad!' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
<strong><span style="line-height: 1.5;"><a href="https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/"><img class="alignleft size-medium wp-image-3849" src="https://www.hotelamrhein.de/wp-content/uploads/2013/04/IMG_5051-200x300.jpg" alt="IMG_5051" width="200" height="300" /></a>In Kooperation mit der Radstation Köln bieten wir Ihnen qualitativ hochwertige City-Bikes zu fairen Preisen. </span></strong>

Erkunden Sie Köln oder Bonn einmal hautnah. Wir bieten Ihnen dafür den nötigen Untersatz. Mountainbikes, Trekkingräder, Tandems, Kinderräder, E-Bikes und Fahrzeuge zur Behindertenmobilität. Fragen Sie uns an, wir liefern direkt zum Hotel am Rhein!

<a title="Radfahrer Special" href="https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/">Mehr erfahren...</a>
[/av_textblock]

[/av_one_half]
[/av_section]

[av_section color='alternate_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Ausflüge mit dem Hotel am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue809' font='entypo-fontello' title='Auf zum Phantasialand' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Bei uns können Sie das Phantasialand-Special buchen. <strong>Unser Angebot für Sie: </strong>1 Übernachtung im Doppelzimmer inklusive reichhaltigem Frühstücksbuffet und eine Tageskarte für das Phantasialand in Brühl.

Und natürlich gibt es bei uns auch noch mehr Ausflugsangebote. Sprechen Sie uns einfach an.

<a title="Freizeitpark Phantasialand" href="https://www.hotelamrhein.de/arrangements-angebote/freizeitpark-phantasialand/">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Afriika_Winter.jpg' attachment='3242' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/freizeitpark-phantasialand/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='86' font='entypo-fontello' title='Für Fahrradfahrer' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Bei uns sind Radfahrer jederzeit herzlich Willkommen. Unser Hotel liegt an den schönsten Fahrradstrecken in der Kölner Rheinregion.

Sie können Ihre Fahrräder bei uns sicher und kostenfrei unterstellen und für kleine Reperaturen steht Ihnen auch ein Werkzeug Set zur Verfügung.

<a title="Radfahr Special" href="https://www.hotelamrhein.de/?page_id=2560">Erfahren Sie mehr...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Bett_Bike-Logo2011_farbig_kleine_Darstellung_jpg.jpg' attachment='3175' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue83f' font='entypo-fontello' title='Kletterspaß und Abenteuer' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Einmal gemeinsam mit Ihrem Partner oder Gleichgesinnten die Wand hoch gehen.

Mit über 2600 Quadratmeter Kletterwand – indoor und outdoor – ist die BRONX Rock Kletterhalle die größte Indoor-Kletterhalle Deutschlands.

<a title="BronxRock – Kletterspaß" href="https://www.hotelamrhein.de/?page_id=2552">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/35691e81a4.jpg' attachment='3173' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/bronxrock-kletterspass/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue8ce' font='entypo-fontello' title='Kurzurlaub am Rhein' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Könnte es etwas schöneres geben als direkt am Rhein zu entspannen?

Genießen Sie das herrliche Panorama mit den vorbeiziehenden Schiffen und lassen Sie sich von der Gastfreundschaft am Rhein verwöhnen.

<a title="Kurzurlaub am Rhein" href="https://www.hotelamrhein.de/?page_id=2554">Mehr erfahren...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/kurzurlaub-am-rhein/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth]
[/av_section]

[av_section color='alternate_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Tagungen, Konferenzen & Events' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue8bb' font='entypo-fontello' title='Tagungen' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
In unserem Haus können Sie drei verschiedene, zeitgemäß ausgestattete und ebenerdig gelegene Tagungsräume mit 24 m², 45 m² und 123 m² nutzen.

Sie werden genügend Platz für die gewünschte Bestuhlung und die angefragte Tagungstechnik haben. <a title="Business" href="https://www.hotelamrhein.de/?page_id=2522">Mehr Informationen... </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box icon='ue80b' font='entypo-fontello' position='left' title='Familienfeiern' link='' linktarget='' linkelement='']
Ob Familientreffen, Taufe oder Trauerfeier – bei uns steht Ihnen ein erfahrenes Team zur Verfügung.

Wir unterstützten Sie gerne bei der Planung, Abwicklung und Durchführung Ihrer Veranstaltung. <a title="Familienfeiern" href="https://www.hotelamrhein.de/?page_id=2516">Mehr Informationen... </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box icon='ue8f1' font='entypo-fontello' position='left' title='Hochzeiten' link='' linktarget='' linkelement='']
Sie können bei uns auch den schönsten Tag Ihres Lebens feiern. Wir bieten Ihnen alle Möglichkeiten Ihre Traumhochzeit mit Rheinblick zu erleben.

Egal ob Sie dabei in einem kleinen intimen Kreis feiern wollen oder eine große Party ausrichten. <a title="Familienfeiern" href="https://www.hotelamrhein.de/?page_id=2516">Mehr Informationen... </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box icon='ue801' font='entypo-fontello' position='left' title='Events' link='' linktarget='' linkelement='']
Mit dem benachbarten “Rheinforum” bieten wir Ihnen eine Eventhalle der besonderen Art mit Platz für bis zu 800 Personen.

Unser Team stellt eine professionelle Organisation und Planung Ihrer Veranstaltung sicher. <a title="Business" href="https://www.hotelamrhein.de/?page_id=2522">Mehr Informationen… </a>
[/av_icon_box]

[/av_one_fourth]
[/av_section]

[av_one_half first]
[av_heading tag='h4' padding='20' heading='Ihr Weg direkt zu uns' color='meta-heading' style='' custom_font='' size='' subheading_active='' subheading_size='' custom_class='']

[av_textblock size='' font_color='' color='']
Sie können uns ideal mit dem Auto oder auch mit der Bahn erreichen. Vor dem Hotel finden Sie einen großen Parkplatz und die Haltestelle der Straßenbahnlinie 16 ist nur wenige Minuten von uns entfernt. <a title="Anfahrt" href="https://www.hotelamrhein.de//?page_id=2344">Details zur Anfahrt finden Sie hier!</a>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello']

[av_textblock size='' font_color='' color='']
<iframe src="https://maps.google.de/maps?ie=UTF8&q=Hotel+am+Rhein&fb=1&gl=de&hq=hotel+am+Rhein&hnear=0x47bf1b71c2d9a62f:0xc908abc06de74b1a,Swisttal&cid=0,0,17093027715360625573&t=m&ll=50.871195,6.984558&spn=0.111579,0.166168&z=12&iwloc=A&output=embed" width="484" height="515" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
[/av_textblock]
[/av_one_half]

[av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']
[av_heading tag='h4' padding='20' heading='Kontaktieren Sie uns' color='meta-heading' style='' custom_font='' size='' subheading_active='' subheading_size=''][/av_heading]

[av_contact email='info@hotelamrhein.de' button='Senden' title='' sent='Ihre Nachricht wurde versendet!' subject='' autorespond='' captcha='active']
[av_contact_field label='Name' type='text' options='' check='is_empty' width='']
[av_contact_field label='Email' type='text' options='' check='is_email' width='']
[av_contact_field label='Betreff' type='text' options='' check='is_empty' width='']
[av_contact_field label='Nachricht' type='textarea' options='' check='is_empty' width='']
[/av_contact]
[/av_one_half]";s:19:"Startseite 20170707";s:16941:"[av_layerslider id='9']

[av_section color='alternate_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Unser Service für Sie' color='' style='' custom_font='' size='' subheading_active='' subheading_size='' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue8ab' font='entypo-fontello' title='Online-Buchung' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' linktarget='_blank' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Hier können Sie Ihr Einzelzimmer, Doppelzimmer oder Ihre Suite in unserem Hotel am Rhein direkt online buchen!

Klicken Sie einfach hier und reservieren Sie noch heute garantiert zum besten Preis.
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Zur-Buchung-001.png' attachment='3150' attachment_size='' align='left' styling='' hover='' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' target='_blank' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation'][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='1' font='entypo-fontello' title='Kontakt' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
<strong>Hotel am Rhein – Wesseling</strong>
Auf dem Rheinberg 2
50389 Wesseling

Tel: +49 (0) 2236 / 325 0
Fax: +49 (0) 2236 / 325 199
Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

Amadeus Code: HNZCK3G6
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue812' font='entypo-fontello' title='Qualität & Service' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
"ankommen und wohfühlen", das ist unser Anspruch im Hotel am Rhein in Wesseling.

Was vor 14 Jahren begann, ist heute gelebte Qualität, die wir lieben. <a title="Qualtität & Service" href="https://www.hotelamrhein.de/?page_id=3372">Erfahren Sie mehr...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/14-Jahre-Quali-001.png' attachment='4522' attachment_size='full' align='center' styling='' hover='' link='page,3372' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation'][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue82b' font='entypo-fontello' title='Bewertung' link='page,4496' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Wir vertrauen TrustYou damit Sie uns vertrauen können.

Lassen Sie sich doch einfach von dem Feedback der Gäste vor Ihnen überzeugen.
[/av_icon_box]

[av_codeblock wrapper_element='' wrapper_element_attributes='']
<iframe src="http://api.trustyou.com/hotels/e458494e-b7cb-4b56-a431-bd1f7762f965/seal.html?size=big" allowtransparency="true" frameborder="0" width="170" height="144" scrolling="no"></iframe>
[/av_codeblock]

[av_textblock size='' font_color='' color='']
<a href="https://www.hotelamrhein.de/unsere-bewertungen/">Zu den Bewertungen</a>
[/av_textblock]

[/av_one_fourth]
[/av_section]

[av_section color='main_color' custom_bg='#f8f8f8' src='' attachment='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' min_height='' padding='small' shadow='shadow' id='']
[av_one_half first]

[av_heading tag='h3' padding='20' heading='Hotel am Rhein ist ein Nichtraucherhotel' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
<strong><img class="alignleft size-medium wp-image-3911" src="https://www.hotelamrhein.de/wp-content/uploads/2013/04/herz-300x282.png" alt="herz" width="300" height="282" />Die große Mehrheit unserer Gäste wünscht sich rauchfreie Zimmer, daher gibt es keine Raucherzimmer mehr!</strong>

Wir sind uns sicher, dass dies die Qualität unserer Hotels und Ihres Aufenthaltes bei uns weiter positiv beeinflussen wird.

Wir hoffen Sie unterstützen uns in dieser Entscheidung und freuen uns auf Ihren nächsten Besuch bei uns.
[/av_textblock]

[/av_one_half][av_one_half]

[av_heading tag='h3' padding='20' heading='Erkunden Sie das schöne Rheinland mit dem Fahrrad!' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
<strong><span style="line-height: 1.5;"><a href="https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/"><img class="alignleft size-medium wp-image-3849" src="https://www.hotelamrhein.de/wp-content/uploads/2013/04/IMG_5051-200x300.jpg" alt="IMG_5051" width="200" height="300" /></a>In Kooperation mit der Radstation Köln bieten wir Ihnen qualitativ hochwertige City-Bikes zu fairen Preisen. </span></strong>

Erkunden Sie Köln oder Bonn einmal hautnah. Wir bieten Ihnen dafür den nötigen Untersatz. Mountainbikes, Trekkingräder, Tandems, Kinderräder, E-Bikes und Fahrzeuge zur Behindertenmobilität. Fragen Sie uns an, wir liefern direkt zum Hotel am Rhein!

<a title="Radfahrer Special" href="https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/">Mehr erfahren...</a>
[/av_textblock]

[/av_one_half]
[/av_section]

[av_section color='alternate_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Ausflüge mit dem Hotel am Rhein' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue809' font='entypo-fontello' title='Auf zum Phantasialand' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Bei uns können Sie das Phantasialand-Special buchen. <strong>Unser Angebot für Sie: </strong>1 Übernachtung im Doppelzimmer inklusive reichhaltigem Frühstücksbuffet und eine Tageskarte für das Phantasialand in Brühl.

Und natürlich gibt es bei uns auch noch mehr Ausflugsangebote. Sprechen Sie uns einfach an.

<a title="Freizeitpark Phantasialand" href="https://www.hotelamrhein.de/arrangements-angebote/freizeitpark-phantasialand/">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Afriika_Winter.jpg' attachment='3242' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/freizeitpark-phantasialand/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='86' font='entypo-fontello' title='Für Fahrradfahrer' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Bei uns sind Radfahrer jederzeit herzlich Willkommen. Unser Hotel liegt an den schönsten Fahrradstrecken in der Kölner Rheinregion.

Sie können Ihre Fahrräder bei uns sicher und kostenfrei unterstellen und für kleine Reperaturen steht Ihnen auch ein Werkzeug Set zur Verfügung.

<a title="Radfahr Special" href="https://www.hotelamrhein.de/?page_id=2560">Erfahren Sie mehr...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Bett_Bike-Logo2011_farbig_kleine_Darstellung_jpg.jpg' attachment='3175' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/radfahr-special/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue83f' font='entypo-fontello' title='Kletterspaß und Abenteuer' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Einmal gemeinsam mit Ihrem Partner oder Gleichgesinnten die Wand hoch gehen.

Mit über 2600 Quadratmeter Kletterwand – indoor und outdoor – ist die BRONX Rock Kletterhalle die größte Indoor-Kletterhalle Deutschlands.

<a title="BronxRock – Kletterspaß" href="https://www.hotelamrhein.de/?page_id=2552">Mehr Informationen...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/35691e81a4.jpg' attachment='3173' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/bronxrock-kletterspass/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box position='left' boxed='' icon='ue8ce' font='entypo-fontello' title='Kurzurlaub am Rhein' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
Könnte es etwas schöneres geben als direkt am Rhein zu entspannen?

Genießen Sie das herrliche Panorama mit den vorbeiziehenden Schiffen und lassen Sie sich von der Gastfreundschaft am Rhein verwöhnen.

<a title="Kurzurlaub am Rhein" href="https://www.hotelamrhein.de/?page_id=2554">Mehr erfahren...</a>
[/av_icon_box]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/04/Rhein_3.jpg' attachment='3174' attachment_size='' align='center' animation='no-animation' link='manually,https://www.hotelamrhein.de/arrangements-angebote/kurzurlaub-am-rhein/' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_fourth]
[/av_section]

[av_section color='alternate_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='20' heading='Tagungen, Konferenzen & Events' color='' style='' custom_font='' size='' subheading_active='' subheading_size='10' custom_class=''][/av_heading]

[av_one_fourth first]

[av_icon_box position='left' boxed='' icon='ue8bb' font='entypo-fontello' title='Tagungen' link='' linktarget='' linkelement='' font_color='' custom_title='' custom_content='' color='' custom_bg='' custom_font='' custom_border='']
In unserem Haus können Sie drei verschiedene, zeitgemäß ausgestattete und ebenerdig gelegene Tagungsräume mit 24 m², 45 m² und 123 m² nutzen.

Sie werden genügend Platz für die gewünschte Bestuhlung und die angefragte Tagungstechnik haben. <a title="Business" href="https://www.hotelamrhein.de/?page_id=2522">Mehr Informationen... </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box icon='ue80b' font='entypo-fontello' position='left' title='Familienfeiern' link='' linktarget='' linkelement='']
Ob Familientreffen, Taufe oder Trauerfeier – bei uns steht Ihnen ein erfahrenes Team zur Verfügung.

Wir unterstützten Sie gerne bei der Planung, Abwicklung und Durchführung Ihrer Veranstaltung. <a title="Familienfeiern" href="https://www.hotelamrhein.de/?page_id=2516">Mehr Informationen... </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box icon='ue8f1' font='entypo-fontello' position='left' title='Hochzeiten' link='' linktarget='' linkelement='']
Sie können bei uns auch den schönsten Tag Ihres Lebens feiern. Wir bieten Ihnen alle Möglichkeiten Ihre Traumhochzeit mit Rheinblick zu erleben.

Egal ob Sie dabei in einem kleinen intimen Kreis feiern wollen oder eine große Party ausrichten. <a title="Familienfeiern" href="https://www.hotelamrhein.de/?page_id=2516">Mehr Informationen... </a>
[/av_icon_box]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_icon_box icon='ue801' font='entypo-fontello' position='left' title='Events' link='' linktarget='' linkelement='']
Mit dem benachbarten “Rheinforum” bieten wir Ihnen eine Eventhalle der besonderen Art mit Platz für bis zu 800 Personen.

Unser Team stellt eine professionelle Organisation und Planung Ihrer Veranstaltung sicher. <a title="Business" href="https://www.hotelamrhein.de/?page_id=2522">Mehr Informationen… </a>
[/av_icon_box]

[/av_one_fourth]
[/av_section]

[av_one_half first]
[av_heading tag='h4' padding='20' heading='Ihr Weg direkt zu uns' color='meta-heading' style='' custom_font='' size='' subheading_active='' subheading_size='' custom_class='']

[av_textblock size='' font_color='' color='']
Sie können uns ideal mit dem Auto oder auch mit der Bahn erreichen. Vor dem Hotel finden Sie einen großen Parkplatz und die Haltestelle der Straßenbahnlinie 16 ist nur wenige Minuten von uns entfernt. <a title="Anfahrt" href="https://www.hotelamrhein.de//?page_id=2344">Details zur Anfahrt finden Sie hier!</a>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello']

[av_textblock size='' font_color='' color='']
<iframe src="https://maps.google.de/maps?ie=UTF8&q=Hotel+am+Rhein&fb=1&gl=de&hq=hotel+am+Rhein&hnear=0x47bf1b71c2d9a62f:0xc908abc06de74b1a,Swisttal&cid=0,0,17093027715360625573&t=m&ll=50.871195,6.984558&spn=0.111579,0.166168&z=12&iwloc=A&output=embed" width="484" height="515" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
[/av_textblock]
[/av_one_half]

[av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']
[av_heading tag='h4' padding='20' heading='Kontaktieren Sie uns' color='meta-heading' style='' custom_font='' size='' subheading_active='' subheading_size=''][/av_heading]

[av_contact email='info@hotelamrhein.de' button='Senden' title='' sent='Ihre Nachricht wurde versendet!' subject='' autorespond='' captcha='active']
[av_contact_field label='Name' type='text' options='' check='is_empty' width='']
[av_contact_field label='Email' type='text' options='' check='is_email' width='']
[av_contact_field label='Betreff' type='text' options='' check='is_empty' width='']
[av_contact_field label='Nachricht' type='textarea' options='' check='is_empty' width='']
[/av_contact]
[/av_one_half]";s:26:"Startseite Corona Mai 2020";s:29547:"[av_revolutionslider av_uid='av-2vhdic' id='1']

[av_heading heading='Das Hotel am Rhein ist geöffnet!' tag='h1' link='' link_target='' style='blockquote modern-quote modern-centered' size='40' subheading_active='' subheading_size='15' margin='' padding='30' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_two_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-7kju5w']
[av_gallery ids='2760,2967,5228,5253,5259,5266' style='thumbnails' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='portfolio' columns='2' imagelink='lightbox' lazyload='avia_lazyload' alb_description='' id='' custom_class='' av_uid='av-jv7vt4cl' admin_preview_bg='']
[/av_two_fifth]

[av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-5k78qc']
[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-1me5r04' admin_preview_bg='']
<div>
<p style="text-align: left;"><strong>Liebe Gäste,</strong></p>
<p style="text-align: left;">wir freuen uns Sie in den herausfordernden Zeiten bei uns „Willkommen“ zu heißen.</p>
<p style="text-align: left;">Weiterhin gilt für unsere Gäste „ Ankommen und Wohlfühlen „</p>
<p style="text-align: left;">Wir haben die äußerst intensive und nervenaufreibende COVID19-Phase produktiv genutzt und unser Hotel für den Neustart vorbereitet. Angefangen bei notwendigen Schönheitsreparaturen, über die Optimierung unserer Abläufe, bis zur Digitalisierung vieler unserer Prozesse - wir wollen die Krise auch als Chance sehen und nutzen!</p>
<p style="text-align: left;">Wir freuen uns auf Ihren Besuch und hoffen, dass Ihnen unsere Anstrengungen zusagen. Natürlich bleiben Einschränkungen bestehen, welche wir strickt zu beachten haben. Wir hoffen, Sie unterstützen uns dabei und natürlich erwarten wir auch weitere Lockerungen, um Ihren Aufenthalt bei uns so angenehm wie möglich zu gestalten.</p>
<p style="text-align: left;">Wenn Sie Fragen zu Buchungen, den Abläufen oder anderen Dingen haben, zögern Sie nicht uns zu unter Telefon +49 (0) 2236 325 - 0 oder per E-Mail an <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a> zu kontaktieren.

In der Hoffnung, Sie bald bei herrlichem Wetter als unsere Gäste willkommen heißen zu dürfen, verbleiben wir mit den besten Wünschen vom Rhein.</p>
<p style="text-align: left;"><strong>Wir freuen uns schon sehr auf Sie!</strong>
<strong> Ihre TOM HOTELS</strong></p>

</div>
[/av_textblock]
[/av_three_fifth]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kapdno8t']
[av_heading heading='Bitte beachten Sie unsere aktuellen Auflagen & Benimmregeln ' tag='h3' link='' link_target='' style='blockquote modern-quote modern-centered' size='30' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-35cqpw'][/av_heading]

[av_tab_container initial='1' position='top_tab' boxed='border_tabs' alb_description='' id='' custom_class='' av_uid='av-kapdeg4u']
[av_tab title='Frühstücksangebot ' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-aw8e6s']
<strong>Frühstücksangebot „ Fit in den Tag“ 06:30 – 09:30 Uhr </strong>

Ob unser kleines Business Frühstück, kontinentales Frühstück oder unsere Lunchbox to go. Sie starten mit Ihrem Frühstück weiterhin fit in den Tag und es werden alle sicherheitsrelevanten Hygienemaßnahmen eingehalten.
[/av_tab]
[av_tab title='Maskenpflicht' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-9n9iv8']
<strong>Maskenpflicht        </strong>

Die Sicherheit, Gesundheit und auch das Wohlbefinden unserer Gäste und Mitarbeiter haben für schon immer und zu jeder Zeit oberste Priorität. Und gerne leisten wir gemeinsam mit Ihnen unseren Beitrag, die Ausbreitung dieses Virus einzudämmen. Wenn wir Sie also mit Schutzmaske begrüßen, dann ist der Look vielleicht neu, aber unser Lächeln für Sie so herzlich wie eh und je. <strong>Das Tragen eines Mundnasenschutzes ist für unsere Mitarbeiter verpflichtend. Zeigen auch Sie uns Ihre Masken! </strong>
[/av_tab]
[av_tab title='Abstandsregelung ' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-6sfyp0']
<strong>Abstandsregelung „ Ihr seid mit Abstand die besten Gäste“ </strong>

Wir haben Abstandzonen markiert, sodass Sie den Mindestabstand  von 1,50 leicht ersehen können. Wir achten auch darauf, dass in allen Bereichen, d.h. im Tagungsbereich, im Pausenbereich sowie im gesamten Hotel die Abstandsregel von 1,50 m eingehalten wird.
[/av_tab]
[av_tab title='Fahrstuhlnutzung' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-5afaz8']
<strong>„Ein Fahrstuhl für Zwei“</strong>

Gedrängel im Fahrstuhl ist ja sowieso nicht schön. Und ganz ehrlich, wer steht schon gerne im überfüllten Fahrstuhl? Darum bitten wir Sie, die den Fahrstuhl nur zu 2 zu betreten. Natürlich können Sie sich auch einen kleinen Treppen-Workout gönnen und Ihrem inneren Schweinehund zeigen, dass er keine Chance hat.
[/av_tab]
[av_tab title='Handhygiene ' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-4mt1es']
<strong>Handhygiene „ Es liegt in Ihrer Hand“ </strong><strong><em>                                                                                                                                                       </em></strong>

An unserem Eingangsbereich stehen Ihnen Desinfektionsständer zur Verfügung.
[/av_tab]
[av_tab title='Kontaktloses Bezahlen 	' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-1vlslg']
<strong>Kontaktloses Bezahlen              </strong>

Aufgrund der aktuellen Pandemie haben wir das Bargeld bei uns im gesamten Hotel abgeschafft!

Bitte nutzen Sie die Möglichkeit  im Voraus mit Kreditkarte zu bezahlen. Sie erhalten Ihre Rechnung via Email. Da die Rezeption nicht 24 Stunden besetzt ist, teilen wir Ihnen in den meisten Fällen im Vorfeld Ihre Zimmernummer mit. Demnach ist es sehr wichtig, eine E-Mail Adresse oder Telefonnummer durchzugeben, sofern wir Sie bei der Buchung noch nicht hinterlegt haben.
[/av_tab]
[av_tab title='Unterweisung' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-3wveas']
<strong>Unterweisung            </strong>

Unsere Mitarbeiter sind in allen Punkten zur Hygiene umfassend geschult und unterwiesen. Dabei achten wir darauf, sie täglich über aktuelle Entwicklungen und mögliche Anpassungen zu unterrichten.
[/av_tab]
[av_tab title='Kaffeepausen Tagungen' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='av-34ydqs']
<strong>Kaffeepausen während Ihrer Tagung</strong>

Wir sorgen dafür, dass unseren Gästen während der Pausen ausreichend Platz zur Verfügung steht. Ihre Teilnehmer haben einen eigenen Kaffeepausenraum oder einen abgegrenzten Bereich.
[/av_tab]
[/av_tab_container]

[av_two_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-7kju5w']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2020/05/bluete-hotel-am-rhein-start-001.jpg' attachment='6471' attachment_size='full' copyright='' caption='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='' target='' title_attr='' alt_attr='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kaqk6iux' admin_preview_bg=''][/av_image]

[/av_two_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-5k78qc']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-1me5r04' admin_preview_bg='']
<div style="text-align: left;">

<strong>Wir bitten um Verständnis, dass die außergewöhnliche Situation der zurückliegenden Wochen die Gewährung eines Preisnachlasses nicht gestattet. </strong>

Wenn Sie in den nächsten Wochen bei uns zu Gast sind, können Sie versichert sein, dass wir in allen Bereichen der beiden Unterkünfte jegliche Hygiene- und Vorsorgemaßnahmen ergriffen haben, um Ihnen einen sicheren Aufenthalt zu gewährleisten!

Wir bedanken uns an dieser Stelle von Herzen für den unermüdlichen Einsatz aller Mitarbeiter im Gesundheitswesen in ganz Europa und bei allen Behörden und Einsatzkräften, die täglich dazu beitragen, diese Krise zu bewältigen.

Unsere Maßnahmen folgen den Vorgaben der jeweiligen örtlichen Gesundheitsbehörden sowie der institutionellen Expertise des Robert-Koch-Instituts, sind stets auf dem aktuellsten Stand und gehen an vielen Stellen über die Vorgaben hinaus. Alle aktuellen Informationen finden Sie auch unter <a href="https://www.land.nrw/corona">https://www.land.nrw/corona</a>

In der Hoffnung, Sie bald bei herrlichem Wetter als unsere Gäste willkommen heißen zu dürfen, verbleiben wir mit den besten Wünschen vom Rhein.

<strong>Wir freuen uns schon sehr auf Sie!</strong>
<strong> Ihre TOM HOTELS</strong>

</div>
[/av_textblock]

[/av_three_fifth]
[/av_section]

[av_codeblock wrapper_element='' wrapper_element_attributes='' av_uid='av-1sphh78']
<div class="viato-price-widget">
<iframe scrolling='no' id='pw-price-widget' src='https://price-widget.viato.travel/?k_id=W0edyg5Br0l4'></iframe>
</div>
[/av_codeblock]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-19npc1w']

[av_section min_height='custom' min_height_pc='25' min_height_px='850px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://www.hotelamrhein.de/wp-content/uploads/2020/05/hotel-am-rhein-zimmer-slide-001.jpg' attachment='6452' attachment_size='full' attach='parallax' position='bottom center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-1rymttg']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-1qr9eec']

[av_heading heading='Unsere Zimmer' tag='h2' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-ahw90'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-1me5r04']
<div>
<ul>
 	<li>Wählen Sie aus 68 Zimmern, davon viele mit Rheinblick</li>
 	<li>Wir bieten ebenfalls Junior- und Familiensuiten</li>
 	<li>Ihr Haustier ist bei uns willkommen</li>
 	<li>WLAN mit Highspeed-Internet</li>
</ul>
</div>
[/av_textblock]

[av_button label='Unsere Zimmer' icon_select='no' icon='ue800' font='entypo-fontello' size='x-large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='page,4933' link_target='' id='' custom_class='' av_uid='av-1kqw1qc' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-1jaxc1w']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/hochzeiten_und_events.jpg' attachment='5743' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-1i6kko4']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-1gkf60k']

[av_heading heading='Tagungen & Events' tag='h2' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-9ol3tw'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-1cwa0as']
<div>

Ob Firmenveranstaltung, Hochzeit, Taufe oder zu einem anderen Anlass – wir machen Ihr Event zu einem ganz besonderen Erlebnis.

</div>
[/av_textblock]

[av_button label='Tagungen & Events' icon_select='no' icon='ue800' font='entypo-fontello' size='x-large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='page,4938' link_target='' id='' custom_class='' av_uid='av-1ayc7v8' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-19npc1w']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/08/HAR_web-305.jpg' attachment='5883' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-17eklg4']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-16x1lec']

[av_heading heading='Unsere Rheinbar' tag='h2' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-7l7exg'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-13or7is']
Genießen Sie warme Speisen, alkoholfreie oder alkoholische Getränke an unserer Rheinbar.
[/av_textblock]

[av_button label='Speisen & Getränke' icon_select='no' icon='ue800' font='entypo-fontello' size='x-large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='manually,https://www.hotelamrhein.de/wp-content/uploads/2018/08/Rheinbar.pdf' link_target='_blank' id='' custom_class='' av_uid='av-11cc5no' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-z8pw44']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' scroll_down='aviaTBscroll_down' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/freizeitprogramm.jpg' attachment='5742' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-yo0v4k']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-wl4j84']

[av_heading heading='Freizeitprogramm' tag='h2' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-28j450'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-se9pys']
<div>

Die Umgebung unseres Hotels bietet ein umfangreiches Freizeitprogramm für die ganze Familie. Neben dem bekannten Phantasialand in Brühl erwarten Sie wunderschöne Radwege, Schiffstouren auf dem Rhein und vieles mehr...

</div>
[/av_textblock]

[av_button label='Freizeitprogramm' icon_select='no' icon='ue800' font='entypo-fontello' size='x-large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='page,4742' link_target='' id='' custom_class='' av_uid='av-r90610' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' height='-250' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='#5a0d39' custom_margin_top='0' custom_margin_bottom='0' icon_select='yes' custom_icon_color='' icon='ue810' font='entypo-fontello' admin_preview_bg='' av_uid='av-p19kz8']

[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2018/04/service_und_kontakt.jpg' attachment='5747' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-2dnfxw']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-midc1w']

[av_heading heading='Service & Kontakt' tag='h2' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-4shq8k'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-jjh63o']
<div>

Unser kompetentes Team steht Ihnen gerne mit Rat und Tat zur Seite. Rufen Sie uns an oder schreiben Sie uns eine Email...

</div>
[/av_textblock]

[av_button label='Service & Kontakt' icon_select='no' icon='ue800' font='entypo-fontello' size='x-large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='page,2334' link_target='' id='' custom_class='' av_uid='av-i1rnmc' admin_preview_bg='']

[/av_two_fifth]
[/av_section]

[av_hr class='custom' icon_select='yes' icon='ue810' font='entypo-fontello' position='center' shadow='no-shadow' height='-250' custom_border='av-border-thin' custom_width='50px' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#5a0d39' custom_icon_color='' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' id='' custom_class='' av_uid='av-gdeilg' admin_preview_bg='']

[av_section min_height='custom' min_height_pc='25' min_height_px='850px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://www.hotelamrhein.de/wp-content/uploads/2018/07/youtube-tn-001.jpg' attachment='5832' attachment_size='full' attach='parallax' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-e7ky44']
[av_one_third first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-d3vz7o']

[av_heading heading='Unser Imagefilm' tag='h2' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-1vand0'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' admin_preview_bg='' av_uid='av-9e3vl0']
Erfahren Sie mehr über das Hotel am Rhein und seine Leistungen.
[/av_textblock]

[av_button label='Imagefilm' icon_select='no' icon='ue800' font='entypo-fontello' size='x-large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='manually,https://www.youtube.com/watch?v=vrKbexTqcUQ' link_target='_blank' id='' custom_class='' av_uid='av-70fdx0' admin_preview_bg='']

[/av_one_third][av_two_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-5gk2ic']

[av_video src='https://www.youtube.com/watch?v=vrKbexTqcUQ' format='16-9' width='16' height='9' av_uid='av-45b3xw']

[/av_two_third]
[/av_section]";s:12:"Tagungen 001";s:9563:"[av_section color='main_color' custom_bg='#f8f8f8' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_one_third first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Hotel-am-Rhein-099.jpg' attachment='3396' align='center' animation='no-animation' link='' target='']

[/av_one_third][av_two_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='']

[av_textblock size='' font_color='' color='']
<div>
<h3>Tagungen, Konferenzen & Events</h3>
</div>
In unserem Haus können Sie drei verschiedene, zeitgemäß ausgestattete und ebenerdig gelegene Tagungsräume mit 24 m², 45 m² und 123 m² nutzen.

Sie werden genügend Platz für die gewünschte Bestuhlung und die angefragte Tagungstechnik haben.

Viel Tageslicht fördert die Teilnehmerkonzentration. Darüber hinaus können wir Ihnen das benachbarte "Rheinforum" mit Platz für bis zu 800 Personen anbieten. Eine Eventhalle der besonderen Art.
<h3>Highspeed-Internet</h3>
Für schnellere Teamarbeit und reibungslose Präsentationen: Genießen Sie eine Übertragungsgeschwindkeit von bis zu 100 Mbit/s.
<h3><strong>Wir stehen Ihnen jederzeit gerne zur Verfügung.</strong></h3>
Unser Team stellt eine professionelle Organisation und Planung Ihrer Veranstaltung sicher. Gerne lassen wir Ihnen eine Tagungsmappe mit allen benötigten Informationen zukommen.

Telefon 02236 325-0
Telefax 02336 325-199
E-Mail <a href="mailto:info@hotelamrhein.de" target="_blank">info@hotelamrhein.de</a>
[/av_textblock]

[/av_two_third]
[/av_section]

[av_section color='main_color' custom_bg='#ffffff' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_heading tag='h3' padding='10' heading='Tagungsräume' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_one_fourth first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Urfeld-002.jpg' attachment='3353' align='center' animation='no-animation' link='page,2596' target=''][/av_image]

[av_textblock]
<strong>Raum “Urfeld” im Detail</strong>
<div>
<div>

<strong>Bestuhlungsmöglichkeiten:</strong>
<ul>
	<li>U-Form für 6 Personen</li>
	<li>Block-Form für 4-10 Personen</li>
	<li>Parlamentarisch für 6 Personen</li>
	<li>Stuhlreihen für 9 Personen</li>
</ul>
<strong>Größe des Raumes:</strong>
<ul>
	<li>24 qm</li>
	<li>4 bis 10 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
	<li>99,00 €</li>
	<li>ist in unseren Pauschalangeboten bereits enthalten</li>
</ul>
</div>
</div>
[/av_textblock]

[/av_one_fourth][av_one_fourth]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Keldenich-002.jpg' attachment='3354' align='center' animation='no-animation' link='page,2598' target=''][/av_image]

[av_textblock]
<strong>Raum “Keldenich” im Detail</strong>
<div>
<div>

<strong>Bestuhlungsmöglichkeiten:</strong>
<ul>
	<li>U-Form für 20 Personen</li>
	<li>Block-Form für 10-20 Personen</li>
	<li>Parlamentarisch für 10-20 Personen</li>
	<li>Stuhlreihen für 10-30 Personen</li>
</ul>
<strong>Größe des Raumes:</strong>
<ul>
	<li>45 qm</li>
	<li>10-30 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
	<li>199,00 €</li>
	<li>ist bei unseren Pauschalangeboten bereits enthalten</li>
</ul>
</div>
</div>
[/av_textblock]

[/av_one_fourth][av_one_fourth]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Berzdorf-002.jpg' attachment='3355' align='center' animation='no-animation' link='page,2600' target=''][/av_image]

[av_textblock]
<strong>Saal “Berzdorf” im Detail</strong>
<div>

<strong>Bestuhlungsmöglichkeiten:</strong>
<ul>
	<li>U-Form für 20-50 Personen</li>
	<li>Parlamentarisch für 20-70 Personen</li>
	<li>Stuhlreihen für 100 Personen</li>
</ul>
<strong>Größe des Raumes:</strong>
<ul>
	<li>123 qm</li>
	<li>20-100 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
	<li>ab 299,00 €</li>
	<li>ist bei unseren Pauschalangeboten bereits enthalten</li>
</ul>
</div>
[/av_textblock]

[/av_one_fourth][av_one_fourth]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/Rheinforum-002.jpg' attachment='3356' align='center' animation='no-animation' link='page,2600' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[av_textblock]
<div>

<strong>Event Halle “Rheinforum”
</strong></div>
Die benachbarte Eventhalle “Rheinforum” in Wesseling bietet für bis zu 800 Personen Platz.

Eine ideale Location für Ihre Kick Offs, Firmenjubiläumsveranstaltungen, Produktpräsentationen und vieles mehr bequem hier durchführen.

Natürlich mit dem unvergesslichen Rheinblick.

<a title="Rheinforum" href="https://www.hotelamrhein.de/?page_id=2602">Weitere Details finden Sie hier!</a>
[/av_textblock]

[/av_one_fourth]
[/av_section]

[av_section color='main_color' custom_bg='#fffdf2' src='' attachment='' position='top left' repeat='no-repeat' attach='scroll' min_height='' padding='small' shadow='shadow' id='']
[av_one_third first]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2014/03/HAR_web-95.jpg' attachment='3573' align='center' animation='no-animation' link='' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2014/03/HAR_web-201.jpg' attachment='3575' align='center' animation='no-animation' link='' target='' styling='' caption='' font_size='' appearance=''][/av_image]

[/av_one_third][av_two_third]

[av_heading tag='h3' padding='10' heading='Buffetideen & Getränkepauschalen' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_tab_container position='sidebar_tab sidebar_tab_left' boxed='border_tabs' initial='1']
[av_tab title='Buffet Standard' icon_select='yes' icon='ue812' font='entypo-fontello']
<b><i>Buffet</i></b>
Crêpes-Röllchen mit Lachs und Frischkäse gefüllt
Blattsalat der Saison mit zwei Dressing Paprika und Champignons gefüllt mit Frischkäse
Getrocknete Tomaten
***
Brot & Butter, Kräuterbutter
Soßen

<b><i>Warm
</i></b>Medaillon vom Schweinefilet im Speckmantel, Pfeffersauce
Rosmarinkartoffeln
Bohnen, glasierte Möhren
Hähnchenbrust auf Schmorgemüse
Weiße Nudeln

<b><i>Dessert</i></b>
Obstspieße „mediterran“
Vanillesauce
Joghurtcreme mit Himbeermark
[/av_tab]
[av_tab title='Buffet Premium' icon_select='yes' icon='ue812' font='entypo-fontello']
<b><i>Buffet</i></b>
Lachs gebeizt, Garnelensalat mit Wurzelgemüse
Puten-Tonnato mit Kapernäpfeln
Anti-Pasti:
Getrocknete Tomaten, Zucchini, marinierte Champignons
Oliven, Tomate-Mozzarella-Spieße
Raukesalat mit Pinienkernen und Parmesan
Balsamico-Dressing
Parmaschinken an mariniertem grünen Spargel
***
Brot & Butter, Soßen

<b><i>Warm
</i></b>Lammragout „Toscana“
Kartoffelgratin
Hähnchenbrust „Sizilianisch“ auf Blattspinat
Rosmarinkartoffeln
Streifen vom Salmfilet auf Wurzelgemüse, Zitronengrassauce
Weiße Nudeln

<b><i>Dessert</i></b>
Tiramisu-Schnitte
Obstsalat

Käseauswahl
Brot & Butter
[/av_tab]
[av_tab title='Getränkepauschale „small“' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Reissdorf-Kölsch</li>
	<li>Krombacher Pils</li>
	<li>1 Rotwein (Hauswein)</li>
	<li>1 Weisswein (Hauswein)</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle)</li>
	<li>Selters Mineralwasser</li>
	<li>Espresso, Café crema, Cappuccino</li>
</ul>
Ab € 29,50 pro Person *
[/av_tab]
[av_tab title='Getränkepauschale “medium”' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Sekt & O-Saft oder Sprizz/Hugo zum Empfang</li>
	<li>1 Rotwein (Auswahl aus 2 Hausweinen)</li>
	<li>1 Weisswein (Auswahl aus 2 Hausweinen)</li>
	<li>Reissdorf-Kölsch</li>
	<li>Krombacher Pils & Pils alkoholfrei</li>
	<li>Krombacher Weizen & Weizen alkoholfrei</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle)</li>
	<li>Selters Mineralwasser</li>
	<li>Kaffeespezialitäten</li>
</ul>
Ab € 36,00 pro Person *
[/av_tab]
[av_tab title='Getränkepauschale “premium”' icon_select='yes' icon='ue812' font='entypo-fontello']
<ul>
	<li>Champagner & Cocktail (z. B. Caipirinha, Mojito,Tequilla Sunrise, Pina Colada)</li>
	<li>2 Rotweine (Auswahl aus verschiedenen Sorten unseres Weinangebotes)</li>
	<li>2 Weissweine (Auswahl aus verschiedenen Sorten unseres Weinangebotes)</li>
	<li>1 Roséwein (Hauswein)</li>
	<li>Reissdorf-Kölsch, Reissdorf-Kölsch alkoholfrei</li>
	<li>Krombacher Pils & Pils alkoholfrei</li>
	<li>Krombacher Weizen & Weizen alkoholfrei</li>
	<li>Softgetränke (Coca Cola, Coca Cola light, Fanta, Sprite, Apfelschorle, Bitter Lemon, Ginger Ale, Tonic Water)</li>
	<li>Selters Mineralwasser</li>
	<li>Kaffeespezialitäten</li>
	<li>1 Digestif pro Person (z. B. Jubiläumsaquavit oder Linie, Williams Birne, Grappa, Korn, Ramazzotti)</li>
</ul>
Ab € 41,50 pro Person *
[/av_tab]
[/av_tab_container]

[av_textblock]
* Verlängerungsstunde: € 5,00 pro Person
Selbstverständlich können alle Getränke auch nach Verbrauch berechnet werden. Alle Preise verstehen sich inklusive der derzeit gültigen Mehrwertsteuer.
[/av_textblock]

[/av_two_third]
[/av_section]";s:15:"Tagung Rheintal";s:2385:"[av_one_third first]
[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/2FP0584.jpg' attachment='2980' align='center' animation='no-animation' link='' target='']
[/av_one_third]

[av_two_third]
[av_textblock]
<div>
<h2>Tagunspauschale "Rheintal"</h2>
</div>
<ul>
	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl, frischem Obst, Joghurt und kleinen Snacks</li>
	<li>Mittagsimbiss (belegte Brötchen und Suppe)</li>
	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl und herzhaften und süßen Snacks</li>
	<li>Standardtechnik (Flipchart, Pinwand, Leinwand)</li>
	<li>Selters Mineralwasser im Tagungsraum</li>
</ul>
€ 39,00 pro Person/Tag

<strong>Raummiete:</strong>
Raum Urfeld (24m²):           € 99,00/Tag
Raum Keldenich (45m²)    € 199,00/Tag
Raum Berzdorf (123m²)     € 299,00/Tag

<b>Einzelpreise: (bei Tagungen unter 10 Personen)</b>
[/av_textblock]

[av_hr class='default' height='50' shadow='no-shadow' position='center']

[av_table purpose='tabular' caption='']
[av_row row_style='avia-heading-row'][av_cell col_style='']Speisen &amp; Getränke:[/av_cell][av_cell col_style='']Preis[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Begrüßungskaffee inkl. Snacks[/av_cell][av_cell col_style='']9,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Kaffeepause vormittags[/av_cell][av_cell col_style='']9,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Kaffeepause nachmittags[/av_cell][av_cell col_style='']9,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mittagessen (inkl. Mineralwasser)[/av_cell][av_cell col_style='']22,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mittagsimbiss inkl. bel. Brötchen &amp; Suppe[/av_cell][av_cell col_style='']10,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Abendessen (inkl. Mineralwasser)[/av_cell][av_cell col_style='']29,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mineralwasser im Tagungsraum[/av_cell][av_cell col_style='']6,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Kaffee, Tee, Softs im Tagungsraum[/av_cell][av_cell col_style='']7,90 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mindestverzehr[/av_cell][av_cell col_style='']5,50 €[/av_cell][/av_row]
[/av_table]
[/av_two_third]";s:18:"Tagungspauschale 1";s:2727:"[av_one_third first]
[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/2FP0590.jpg' attachment='2981' align='center' animation='no-animation' link='' target='']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2013/09/2FP0584.jpg' attachment='2980' align='center' animation='no-animation' link='' target='']
[/av_one_third]

[av_two_third]
[av_textblock ]
<div>
<h3>Tagungspauschale "Rheintal"</h3>
</div>
<ul>
	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl, frischem Obst, Joghurt und kleinen Snacks</li>
	<li>Mittagsimbiss (belegte Brötchen und Suppe)</li>
	<li>Kaffeepause mit Kaffeespezialitäten, Teeauswahl und herzhaften und süßen Snacks</li>
	<li>Standardtechnik (Flipchart, Pinwand, Leinwand)</li>
	<li>Selters Mineralwasser im Tagungsraum</li>
</ul>
€ 39,00 pro Person/Tag

<strong>Raummiete:</strong>
Raum Urfeld (24m²):           € 99,00/Tag
Raum Keldenich (45m²)    € 199,00/Tag
Raum Berzdorf (123m²)     € 299,00/Tag

<strong>Gerne vereinbaren wir einen Termin unter:</strong>
Telefon: 02236 325-0
Telafax:02236 325-199
oder E-Mail: <a href="mailto:info@hotelamrhein.de">info@hotelamrhein.de</a>

[av_hr class='default' height='50' shadow='no-shadow' position='center']

<b>Einzelpreise: (bei Tagungen unter 10 Personen)</b>
[/av_textblock]

[av_table purpose='tabular' caption='']
[av_row row_style='avia-heading-row'][av_cell col_style='']Speisen &amp; Getränke:[/av_cell][av_cell col_style='']Preis[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Begrüßungskaffee inkl. Snacks[/av_cell][av_cell col_style='']9,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Kaffeepause vormittags[/av_cell][av_cell col_style='']9,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Kaffeepause nachmittags[/av_cell][av_cell col_style='']9,00 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mittagessen (inkl. Mineralwasser)[/av_cell][av_cell col_style='']22,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mittagsimbiss inkl. bel. Brötchen &amp; Suppe[/av_cell][av_cell col_style='']10,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Abendessen (inkl. Mineralwasser)[/av_cell][av_cell col_style='']29,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mineralwasser im Tagungsraum[/av_cell][av_cell col_style='']6,50 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Kaffee, Tee, Softs im Tagungsraum[/av_cell][av_cell col_style='']7,90 €[/av_cell][/av_row]
[av_row row_style=''][av_cell col_style='']Mindestverzehr[/av_cell][av_cell col_style='']5,50 €[/av_cell][/av_row]
[/av_table]
[/av_two_third]";s:20:"Tagungsraeume-Reiter";s:2511:"[av_tab_container position='top_tab' boxed='border_tabs' initial='1']
[av_tab title='Raum Urfeld, bis 12 Personen' icon_select='no' icon='ue800' font='entypo-fontello']
<div>
<div>

<strong><a href="https://www.hotelamrhein.de/wp-content/uploads/2013/09/Urfeld-0011.jpg"><img class="alignright wp-image-3333 size-medium" src="https://www.hotelamrhein.de/wp-content/uploads/2013/09/Urfeld-0011-284x300.jpg" alt="" width="284" height="300" /></a>Bestuhlungsmöglichkeiten:</strong>
<ul>
 	<li>U-Form für 6 Personen</li>
 	<li>Block-Form für 4-10 Personen</li>
 	<li>Parlamentarisch für 6 Personen</li>
 	<li>Stuhlreihen für 9 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>24 qm</li>
 	<li>bis 12 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>99,00 €</li>
 	<li>ist in unseren Pauschalangeboten bereits enthalten</li>
</ul>
</div>
</div>
[/av_tab]
[av_tab title='Raum Keldenich, bis 30 Personen' icon_select='no' icon='ue800' font='entypo-fontello']
<div>
<div>

<strong><a href="https://www.hotelamrhein.de/wp-content/uploads/2013/09/Keldenich-0011.jpg"><img class="alignright wp-image-3338 size-medium" src="https://www.hotelamrhein.de/wp-content/uploads/2013/09/Keldenich-0011-300x184.jpg" alt="" width="300" height="184" /></a>Bestuhlungsmöglichkeiten:</strong>
<ul>
 	<li>U-Form für 20 Personen</li>
 	<li>Block-Form für 10-20 Personen</li>
 	<li>Parlamentarisch für 10-20 Personen</li>
 	<li>Stuhlreihen für 10-30 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>45 qm</li>
 	<li>bis 30 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>199,00 €</li>
 	<li>ist bei unseren Pauschalangeboten bereits enthalten</li>
</ul>
</div>
</div>
[/av_tab]
[av_tab title='Saal Berzdorf, bis 100 Personen' icon_select='no' icon='ue800' font='entypo-fontello']
<strong><a href="https://www.hotelamrhein.de/wp-content/uploads/2013/09/Berzdorf-0011.jpg"><img class="alignright wp-image-3340 size-medium" src="https://www.hotelamrhein.de/wp-content/uploads/2013/09/Berzdorf-0011-300x112.jpg" alt="" width="300" height="112" /></a>Bestuhlungsmöglichkeiten:</strong>
<ul>
 	<li>U-Form für 20-50 Personen</li>
 	<li>Parlamentarisch für 20-70 Personen</li>
 	<li>Stuhlreihen für 100 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>123 qm</li>
 	<li>bis 100 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>ab 299,00 €</li>
 	<li>ist bei unseren Pauschalangeboten bereits enthalten</li>
</ul>
[/av_tab]
[/av_tab_container]";s:24:"Tagungsraeume-Rheinforum";s:2776:"[av_tab_container position='top_tab' boxed='border_tabs' initial='1']
[av_tab title='Foyer, bis 20 Pers.' icon_select='no' icon='ue800' font='entypo-fontello']
<strong>Bestuhlungsmöglichkeiten:</strong>
<ul>
 	<li>U-Form für 15 Personen</li>
 	<li>Block-Form für 20 Personen</li>
</ul>
<strong>Größe des Raumes:</strong>
<ul>
 	<li>66 qm</li>
 	<li>15-20 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>auf Anfrage</li>
</ul>
[/av_tab]
[av_tab title='Bar Rheinsaal, bis 30 Pers.' icon_select='no' icon='ue800' font='entypo-fontello']
<div>

<strong>Bestuhlungsmöglichkeiten:</strong>

</div>
<ul>
 	<li>Stehtische</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>14 qm</li>
 	<li>30 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>auf Anfrage</li>
</ul>
[/av_tab]
[av_tab title='Empore, bis 80 Pers.' icon_select='no' icon='ue800' font='entypo-fontello']
<div>

<strong>Bestuhlungsmöglichkeiten:</strong>

</div>
<ul>
 	<li>U-Form für 20 Personen</li>
 	<li>Block-Form für 40 Personen</li>
 	<li>Stuhlreihen für 80 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>30 qm</li>
 	<li>20-80 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>auf Anfrage</li>
</ul>
[/av_tab]
[av_tab title='Rheinsaal, bis 400 Pers.' icon_select='no' icon='ue800' font='entypo-fontello']
<table border="0" width="400px" cellspacing="2" cellpadding="2">
<tbody>
<tr>
<td valign="top">Rheinsaal vorne, bis 45 Pers.</td>
<td valign="top">Rheinsaal rechts, bis 70 Pers.</td>
<td valign="top">Rheinsaal, bis 400 Pers.</td>
</tr>
<tr>
<td valign="top">
<div>

<strong>Bestuhlungsmöglichkeiten:</strong></div>
<ul>
 	<li>U-Form für 25 Personen</li>
 	<li>Block-Form für 30 Personen</li>
 	<li>Parlamentarisch für 30 Personen</li>
 	<li>Stuhlreihen für 45 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>60 qm</li>
 	<li>25-45 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>auf Anfrage</li>
</ul>
</td>
<td valign="top">
<div>

<strong>Bestuhlungsmöglichkeiten:</strong></div>
<ul>
 	<li>Parlamentarisch für 45 Personen</li>
 	<li>Stuhlreihen für 70 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>85 qm</li>
 	<li>45-70 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>auf Anfrage</li>
</ul>
</div>
</div></td>
<td valign="top">
<div>

<strong>Bestuhlungsmöglichkeiten:</strong></div>
<ul>
 	<li>U-Form für 80 Personen</li>
 	<li>Block-Form für 30 Personen</li>
 	<li>Parlamentarisch für 250 Personen</li>
 	<li>Stuhlreihen für 400 Personen</li>
</ul>
<strong>Größe des Raums:</strong>
<ul>
 	<li>120 qm</li>
 	<li>80-400 Personen</li>
</ul>
<strong>Raummiete:</strong>
<ul>
 	<li>auf Anfrage</li>
</ul>
</td>
</tr>
</tbody>
</table>
[/av_tab]
[/av_tab_container]";s:12:"Teaser gross";s:1868:"[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' id='' color='main_color' custom_bg='' src='https://www.hotelamrhein.de/wp-content/uploads/2016/02/Phantasialand-Black-Mamba_02.jpg' attachment='4034' attachment_size='full' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='']
[av_two_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='']

[av_heading heading='Phantasialand-Special' tag='h2' style='' size='' subheading_active='' subheading_size='15' padding='5' color='' custom_font=''][/av_heading]

[av_textblock size='' font_color='' color='']
<strong>Abenteuer erleben im Phantasialand und übernachten im Hotel am Rhein inklusive reichhaltigem Frühstücksbuffet.</strong>

<strong>Paketpreis ab 121,50 €</strong>
[/av_textblock]

[av_button_big label='Jetzt Phantasialand-Special buchen' description_pos='below' link='manually,http://booking.viatocrs.de/cbe/index.html?pr=W0edyg5Br0l4' link_target='' icon_select='yes-left-icon' icon='ue881' font='entypo-fontello' custom_font='#ffffff' color='custom' custom_bg='#000000' color_hover='custom' custom_bg_hover='#444444'][/av_button_big]

[av_hr class='invisible' height='450' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello']

[/av_two_fifth]
[/av_section]";s:17:"Therme Euskirchen";s:18418:"[av_section min_height='custom' min_height_px='850px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' scroll_down='aviaTBscroll_down' custom_arrow_bg='' id='sektion-phantasialand' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://www.hotelamrhein.de/wp-content/uploads/2019/04/Therme-Euskirchen-001.jpg' attachment='6125' attachment_size='full' attach='parallax' position='center center' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-2y7dla5']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-2wq883x']

[/av_one_third][av_two_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='20px' padding_sync='true' border='' border_color='' radius='0' radius_sync='true' background_color='#fcfcfc' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-11bslp']

[av_heading heading='Urlaub im Paradies  - Die Therme Euskirchen' tag='h2' link='manually,http://' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='5' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-q753sd'][/av_heading]

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jub7k40s' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2s60g19' admin_preview_bg='']
<section class="av_textblock_section ">Genießen Sie eine Auszeit in der Therme Euskirchen in Kombination mit einer Übernachtung im Hotel am Rhein.

Das Hotel am Rhein in Wesseling befindet sich nur rund 30 Autominuten von der einziartigen Thermen- & Badewelt entfernt. Übernachten Sie im Doppelzimmer Superior mit direktem Blick auf den Rhein.

Nach einem entspannten Tag im Palmemparadies, haben Sie die Möglichkeit den Abend an der Hotelbar ausklingen zu lassen und den Rheinblick zu genießen.

Am Morgen erwartet Sie unser Frühstück, welches keine Wünsche offen lässt.

</section>
[/av_textblock]

[/av_two_third][av_one_third first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-2ojqdfx']

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-26953hp']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' id='' custom_class='' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-oiqw6l'][av_cell col_style='' av_uid='av-m5ajq5']1 Übernachtung[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-k9tpgd'][av_cell col_style='' av_uid='av-j7mja5']ab 109,50 € im DZ[/av_cell][/av_row]
[av_row row_style='' av_uid='av-h3b6yl'][av_cell col_style='' av_uid='av-f9hxr1']1 Übernachtung in der jeweiligen Zimmerkategorie
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-ed9qrx'][av_cell col_style='' av_uid='av-culq0d']inklusive Frühstück [/av_cell][/av_row]
[av_row row_style='' av_uid='av-12bdgt'][av_cell col_style='' av_uid='av-8t6t7x']1 Eintritts-/Tageskarte p.P. für das Palmenparadies mit Vitaltherme & Sauna
[/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-7vwoi5'][av_cell col_style='' av_uid='av-63qd7h'][av_button label='JETZT ANFRAGEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/therme-euskirchen/#buchung' link_target='' size='large' position='center' label_display='' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-4f7nkd'][av_cell col_style='' av_uid='av-2w8wzx']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='70px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-26953hp']

[av_table purpose='pricing' pricing_table_design='avia_pricing_minimal' pricing_hidden_cells='' caption='' responsive_styling='avia_responsive_table' id='' custom_class='' av_uid='av-24wumm5']
[av_row row_style='avia-heading-row' av_uid='av-oggl7x'][av_cell col_style='' av_uid='av-m5ku3h']2 Übernachtungen[/av_cell][/av_row]
[av_row row_style='avia-pricing-row' av_uid='av-k7m6st'][av_cell col_style='' av_uid='av-jasci5']ab 149,25 € im DZ[/av_cell][/av_row]
[av_row row_style='' av_uid='av-hogid9'][av_cell col_style='' av_uid='av-g9hl9p']2 Übernachtungen in der jeweiligen Zimmerkategorie
[/av_cell][/av_row]
[av_row row_style='' av_uid='av-epx7dp'][av_cell col_style='' av_uid='av-cqgbx9']inklusive Frühstück [/av_cell][/av_row]
[av_row row_style='' av_uid='av-bk7eu5'][av_cell col_style='' av_uid='av-9c21dp']1 Eintritts-/Tageskarte p.P. für das Palmenparadies mit Vitaltherme & Sauna
[/av_cell][/av_row]
[av_row row_style='avia-button-row' av_uid='av-7b52x9'][av_cell col_style='' av_uid='av-5yum1p'][av_button label='JETZT ANFRAGEN' link='manually,https://www.hotelamrhein.de/freizeitprogramm/therme-euskirchen/#buchung' link_target='' size='large' position='center' label_display='' icon_select='no' icon='ue87d' font='entypo-fontello' color='custom' custom_bg='#5a0d39' custom_font='#ffffff' av_uid='av-1q4stkt' admin_preview_bg='']

[/av_cell][/av_row]
[av_row row_style='' av_uid='av-3p52zh'][av_cell col_style='' av_uid='av-21q8j1']Preise gelten pro Person[/av_cell][/av_row]
[/av_table]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' id='' color='main_color' custom_bg='#ffffff' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='av-16uf6gd']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-147ybwd']

[av_image src='https://www.hotelamrhein.de/wp-content/uploads/2019/04/Therme-Euskirchen-005.jpg' attachment='6132' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='av-12gnb59' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-11kstzx']

[av_heading heading='Ihr Südseeurlaub ganz nah' tag='h3' link='manually,http://' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-hoq5l9'][/av_heading]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-ylp5zh' admin_preview_bg='']
<strong>Willkommen im Paradies.</strong>

In einem einzigartigen Palmenparadies mit beeindruckender Vitaltherme & Sauna. Lassen Sie sich in unsere Welt unter Palmen entführen und genießen Sie Stunden der Entspannung und Ruhe.

Gehen Sie mit uns auf eine außergewöhnliche Wellness-Reise und bringen Sie Körper, Geist und Seele in lichtdurchfluteten, paradiesischen Oasen in Einklang.

Tauchen Sie ein in das kristallklare Wasser unserer Lagunen, an 365 Tagen im Jahr bei 33° Grad C Wassertemperatur. Gönnen Sie sich Ihre Auszeit puren Wohlbefindens. Wir freuen uns auf Sie!
[/av_textblock]

[av_button label='JETZT ANFRAGEN' icon_select='no' icon='ue800' font='entypo-fontello' size='large' position='left' label_display='' title_attr='' color='custom' custom_bg='#130f0d' custom_font='#ffffff' link='manually,https://www.hotelamrhein.de/freizeitprogramm/therme-euskirchen/#buchung' link_target='' id='' custom_class='' av_uid='av-jv7w2ud4' admin_preview_bg='']

[/av_one_half]
[/av_section]

[av_slideshow_full size='featured' min_height='0px' stretch='' animation='slide' conditional_play='' autoplay='true' interval='4' control_layout='av-control-default' src='' attachment='' attachment_size='' position='top left' repeat='no-repeat' attach='scroll' av_uid='av-jub89jyb']
[av_slide_full id='6128' av_uid='av-60kzf1' slide_type='' video='http://' mobile_image='' fallback_link='http://' video_format='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' custom_title_size='' custom_content_size='' caption_pos='caption_bottom' link_apply='' link='' link_target='' button_label='Click me' button_color='light' link1='' link_target1='' button_label2='Click me' button_color2='light' link2='' link_target2='' font_color='' custom_title='' custom_content='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_slide_full]
[av_slide_full id='6130' av_uid='av-43x9xp' slide_type='' video='http://' mobile_image='' fallback_link='http://' video_format='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' custom_title_size='' custom_content_size='' caption_pos='caption_bottom' link_apply='' link='' link_target='' button_label='Click me' button_color='light' link1='' link_target1='' button_label2='Click me' button_color2='light' link2='' link_target2='' font_color='' custom_title='' custom_content='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_slide_full]
[av_slide_full id='6129' av_uid='av-2cj95p' slide_type='' video='http://' mobile_image='' fallback_link='http://' video_format='' video_ratio='16:9' video_controls='' video_mute='' video_loop='' video_autoplay='' title='' custom_title_size='' custom_content_size='' caption_pos='caption_bottom' link_apply='' link='' link_target='' button_label='Click me' button_color='light' link1='' link_target1='' button_label2='Click me' button_color2='light' link2='' link_target2='' font_color='' custom_title='' custom_content='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_slide_full]
[/av_slideshow_full]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='buchung' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-atiri5']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-9em7a5']

[av_contact title='Buchungsanfrage Therme Euskirchen' button='Senden' on_send='' sent='Deine Nachricht wurde versendet!' link='manually,http://' captcha='' captcha_theme='light' captcha_size='normal' captcha_score='0.5' email='info@hotelamrhein.de' from_email='' subject='' autoresponder_email='info@hotelamrhein.de' autoresponder_reply_to='' autorespond='' form_align='' color='' heading_tag='' heading_class='' alb_description='' id='' custom_class='' aria_label='' av_uid='av-jv6noos4' admin_preview_bg='']
[av_contact_field label='Anrede' type='select' options='Frau,Herr' check='' width='element_half' av_uid='av-f2xydp'][/av_contact_field]
[av_contact_field label='Titel' type='text' options='' check='' width='element_half' av_uid='av-evqe8t'][/av_contact_field]
[av_contact_field label='Vorname und Nachname' type='text' options='' check='is_empty' width='' av_uid='av-7kwsyl' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Telefon' type='text' options='' check='is_phone' width='element_half' av_uid='av-d7qz1p'][/av_contact_field]
[av_contact_field label='E-Mail' type='text' options='' check='is_email' width='element_half' av_uid='av-bead31'][/av_contact_field]
[av_contact_field label='Strasse + Hausnummer' type='text' options='' check='is_empty' width='element_half' av_uid='av-9h3d5p'][/av_contact_field]
[av_contact_field label='Postleitzahl und Ort' type='text' options='' check='is_empty' width='element_half' av_uid='av-otowd'][/av_contact_field]
[av_contact_field label='Personenzahl' type='select' options='1,2,3,4' check='is_number' width='' av_uid='av-3jzolp' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Anreise' type='datepicker' options='' check='is_empty' width='element_half' av_uid='av-5o6ivx'][/av_contact_field]
[av_contact_field label='Abreise' type='datepicker' options='' check='is_empty' width='element_half' av_uid='av-3xjq1p'][/av_contact_field]
[av_contact_field label='Nachricht' type='textarea' check='is_empty' options='' multi_select='' av_contact_preselect='' width='' av_uid='av-1w4z5p'][/av_contact_field]
[/av_contact]

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' av_uid='av-5acesd']

[av_heading heading='Comfort direkt am Rhein' tag='h3' link='' link_target='' style='' size='' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' id='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size=''][/av_heading]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-2l2e99' admin_preview_bg='']
Unsere 68 großen, hell und modern eingerichteten Einzelzimmer, Doppelzimmer und Suiten in Wesseling bieten hohen Komfort und Behaglichkeit. Neben unseren Komfort-Zimmern stehen Ihnen Superior-Zimmer mit Rheinblick und Wasserkocher zur Kaffee- und Teezubereitung sowie 2 Juniorsuiten, 3 Familiensuiten und eine Rheinblicksuite je nach Verfügbarkeit zur Verfügung.

Unvergesslich bleibt der Blick auf den Rhein, den Sie vom größten Teil der Zimmer, der Lobby-Bar und dem Frühstücksraum aus haben.

Haustiere sind bei uns jederzeit Willkommen.

<strong>Unsere Pakete beinhalten jeweils: </strong>
<ul>
 	<li>1 Übernachtung in der jeweiligen Zimmerkategorie</li>
 	<li>inklusive Frühstück</li>
 	<li>1 Eintritts-/Tageskarte p.P. für das Palmenparadies mit Vitaltherme &amp; Sauna</li>
</ul>
<strong>*Preise gelten pro Person</strong>
[/av_textblock]

[av_gallery ids='2760,2967,5228,5253,5259,5266' style='thumbnails' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='portfolio' columns='2' imagelink='lightbox' lazyload='avia_lazyload' av_uid='av-jv7vt4cl' admin_preview_bg='']

[/av_one_half][/av_section]";s:12:"ZImmer 50-50";s:2069:"[av_one_half first]
[av_gallery ids='2925,2927,3454,2928,2935,2940,2930,3456,2932,2933,2941,3457,3583,3584,3585' style='big_thumb' preview_size='portfolio' crop_big_preview_thumbnail='avia-gallery-big-crop-thumb' thumb_size='thumbnail' columns='6' imagelink='lightbox' lazyload='avia_lazyload']
[/av_one_half]

[av_one_half]
[av_textblock]
<h3><strong>Unsere Zimmer</strong></h3>
Unsere 68 großen, hell und modern eingerichteten Einzelzimmer, Doppelzimmer und Suiten in Wesseling bieten hohen Komfort und Behaglichkeit. Neben unseren Komfort-Zimmern stehen Ihnen Superior-Zimmer mit Rheinblick und Wasserkocher zur Kaffee- und Teezubereitung sowie 2 Juniorsuiten, 3 Familiensuiten und eine Rheinblicksuite je nach Verfügbarkeit zur Verfügung.

Unvergesslich bleibt der Blick auf den Rhein, den Sie vom größten Teil der Zimmer, der Lobby-Bar und dem Frühstücksraum aus haben.

Haustiere sind bei uns jederzeit Willkommen.
<h3>Entspannung pur in unserer Rheinblicksuite.</h3>
Das Badezimmer ist mit einer Eckbadewanne ausgestattet und bietet einen Blick auf den Rhein. In der Suite finden Sie zusätzlich eine Sitzecke, eine Minibar - Wasserkocher für Kaffee- und Teezubereitung sowie ein Schreibtisch.

Genießen Sie das herrliche Panorama und die vorbeiziehenden Schiffe. Könnte es was schöneres geben als direkt am Rhein zu entspannen? Besonders beliebt ist die Rheinblicksuite auch als Hochzeitssuite!
[/av_textblock]

[av_hr class='default' height='50' shadow='no-shadow' position='center']

[av_textblock]
<strong>Sie wollen direkt online buchen oder haben noch Fragen?</strong>

Wir stehen Ihnen jederzeit gerne unter Telefon 02236 325-0, Telefax 02336 325-199 oder E-Mail <a href="mailto:info@hotelamrhein.de" target="_blank">info@hotelamrhein.de </a>zur Verfügung.

<a title="Online Buchen" href="https://www.hotelamrhein.de/?page_id=2613"><img class="alignnone size-full wp-image-3150" src="https://www.hotelamrhein.de/wp-content/uploads/2013/04/Zur-Buchung-001.png" alt="Zur-Buchung-001" width="184" height="43" /></a>
[/av_textblock]
[/av_one_half]";}